+
+ 
+ 
+
+
+
+
+
+
+ 
+
+
+
+
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
diff --git a/vendor/charm.land/bubbletea/v2/Taskfile.yaml b/vendor/charm.land/bubbletea/v2/Taskfile.yaml
new file mode 100644
index 000000000..35072035d
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/Taskfile.yaml
@@ -0,0 +1,14 @@
+# https://taskfile.dev
+
+version: '3'
+
+tasks:
+ lint:
+ desc: Run lint
+ cmds:
+ - golangci-lint run
+
+ test:
+ desc: Run tests
+ cmds:
+ - go test ./... {{.CLI_ARGS}}
diff --git a/vendor/charm.land/bubbletea/v2/UPGRADE_GUIDE_V2.md b/vendor/charm.land/bubbletea/v2/UPGRADE_GUIDE_V2.md
new file mode 100644
index 000000000..2ca7b0a08
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/UPGRADE_GUIDE_V2.md
@@ -0,0 +1,573 @@
+# Bubble Tea v2 Upgrade Guide
+
+This guide covers everything you need to change when upgrading from Bubble Tea v1 to v2. For a tour of all the exciting new features, check out the [What's New](https://github.com/charmbracelet/bubbletea/releases/tag/v2.0.0) doc.
+
+> [!NOTE]
+> We don't take API changes lightly and strive to make the upgrade process as simple as possible. If something feels way off, let us know.
+
+## Migration Checklist
+
+Here's the short version — a checklist you can follow top to bottom. Each item links to the relevant section below.
+
+- [ ] [Update import paths](#import-paths)
+- [ ] [Change `View() string` to `View() tea.View`](#view-returns-a-teaview-now)
+- [ ] [Replace `tea.KeyMsg` with `tea.KeyPressMsg`](#key-messages)
+- [ ] [Update key fields: `msg.Type` / `msg.Runes` / `msg.Alt`](#key-messages)
+- [ ] [Replace `case " ":` with `case "space":`](#key-messages)
+- [ ] [Update mouse message usage](#mouse-messages)
+- [ ] [Rename mouse button constants](#mouse-messages)
+- [ ] [Remove old program options → use View fields](#removed-program-options)
+- [ ] [Remove imperative commands → use View fields](#removed-commands)
+- [ ] [Remove old program methods](#removed-program-methods)
+- [ ] [Rename `tea.WindowSize()` → `tea.RequestWindowSize`](#renamed-apis)
+- [ ] [Replace `tea.Sequentially(...)` → `tea.Sequence(...)`](#renamed-apis)
+
+## Import Paths
+
+The module path changed to a vanity domain. Lip Gloss moved too.
+
+```go
+// Before
+import tea "github.com/charmbracelet/bubbletea"
+import "github.com/charmbracelet/lipgloss"
+
+// After
+import tea "charm.land/bubbletea/v2"
+import "charm.land/lipgloss/v2"
+```
+
+## The Big Idea: Declarative Views
+
+The single biggest change in v2 is the shift from **imperative commands** to **declarative View fields**. In v1, you'd use program options like `tea.WithAltScreen()` and commands like `tea.EnterAltScreen` to toggle terminal features on and off. In v2, you just set fields on the `tea.View` struct in your `View()` method and Bubble Tea handles the rest.
+
+This means: no more startup option flags, no more toggle commands, no more fighting over state. Just declare what you want and Bubble Tea will make it so.
+
+```go
+// v1: imperative — scattered across NewProgram, Init, and Update
+p := tea.NewProgram(model{}, tea.WithAltScreen(), tea.WithMouseCellMotion())
+
+// v2: declarative — everything lives in View()
+func (m model) View() tea.View {
+ v := tea.NewView("Hello!")
+ v.AltScreen = true
+ v.MouseMode = tea.MouseModeCellMotion
+ return v
+}
+```
+
+Keep this in mind as you go through the rest of the guide — most of the "removed" things simply moved into View fields.
+
+## View Returns a `tea.View` Now
+
+The `View()` method no longer returns a `string`. It returns a `tea.View` struct.
+
+```go
+// Before:
+func (m model) View() string {
+ return "Hello, world!"
+}
+
+// After:
+func (m model) View() tea.View {
+ return tea.NewView("Hello, world!")
+}
+```
+
+You can also use the longer form if you need to set additional fields:
+
+```go
+func (m model) View() tea.View {
+ var v tea.View
+ v.SetContent("Hello, world!")
+ v.AltScreen = true
+ return v
+}
+```
+
+The `tea.View` struct has fields for everything that used to be controlled by options and commands:
+
+| View Field | What It Does |
+|---|---|
+| `Content` | The rendered string (set via `SetContent()` or `NewView()`) |
+| `AltScreen` | Enter/exit the alternate screen buffer |
+| `MouseMode` | `MouseModeNone`, `MouseModeCellMotion`, or `MouseModeAllMotion` |
+| `ReportFocus` | Enable focus/blur event reporting |
+| `DisableBracketedPasteMode` | Disable bracketed paste |
+| `WindowTitle` | Set the terminal window title |
+| `Cursor` | Control cursor position, shape, color, and blink |
+| `ForegroundColor` | Set the terminal foreground color |
+| `BackgroundColor` | Set the terminal background color |
+| `ProgressBar` | Show a native terminal progress bar |
+| `KeyboardEnhancements` | Request keyboard enhancement features |
+| `OnMouse` | Intercept mouse messages based on view content |
+
+## Key Messages
+
+Key messages got a major overhaul. Here's the quick rundown:
+
+### `tea.KeyMsg` is now an interface
+
+In v1, `tea.KeyMsg` was a struct you'd match on for key presses. In v2, it's an **interface** that covers both key presses and releases. For most code, you want `tea.KeyPressMsg`:
+
+```go
+// Before:
+case tea.KeyMsg:
+ switch msg.String() {
+ case "q":
+ return m, tea.Quit
+ }
+
+// After:
+case tea.KeyPressMsg:
+ switch msg.String() {
+ case "q":
+ return m, tea.Quit
+ }
+```
+
+If you want to handle both presses and releases, use `tea.KeyMsg` and type-switch inside:
+
+```go
+case tea.KeyMsg:
+ switch key := msg.(type) {
+ case tea.KeyPressMsg:
+ // key press
+ case tea.KeyReleaseMsg:
+ // key release
+ }
+```
+
+### Key fields changed
+
+| v1 | v2 | Notes |
+|---|---|---|
+| `msg.Type` | `msg.Code` | A `rune` — can be `tea.KeyEnter`, `'a'`, etc. |
+| `msg.Runes` | `msg.Text` | Now a `string`, not `[]rune` |
+| `msg.Alt` | `msg.Mod` | `msg.Mod.Contains(tea.ModAlt)` for alt, etc. |
+| `tea.KeyRune` | — | Check `len(msg.Text) > 0` instead |
+| `tea.KeyCtrlC` | — | Use `msg.String() == "ctrl+c"` or check `msg.Code` + `msg.Mod` |
+
+### Space bar changed
+
+Space bar now returns `"space"` instead of `" "` when using `msg.String()`:
+
+```go
+// Before:
+case " ":
+
+// After:
+case "space":
+```
+
+`key.Code` is still `' '` and `key.Text` is still `" "`, but `String()` returns `"space"`.
+
+### Ctrl+key matching
+
+```go
+// Before:
+case tea.KeyCtrlC:
+ // ctrl+c
+
+// After (option A — string matching):
+case tea.KeyPressMsg:
+ switch msg.String() {
+ case "ctrl+c":
+ // ctrl+c
+ }
+
+// After (option B — field matching):
+case tea.KeyPressMsg:
+ if msg.Code == 'c' && msg.Mod == tea.ModCtrl {
+ // ctrl+c
+ }
+```
+
+### New Key fields
+
+These are new in v2 and don't have v1 equivalents:
+
+- **`key.ShiftedCode`** — the shifted key code (e.g., `'B'` when pressing shift+b)
+- **`key.BaseCode`** — the key on a US PC-101 layout (handy for international keyboards)
+- **`key.IsRepeat`** — whether the key is auto-repeating (Kitty protocol / Windows Console only)
+- **`key.Keystroke()`** — like `String()` but always includes modifier info
+
+## Paste Messages
+
+Paste events no longer come in as `tea.KeyMsg` with a `Paste` flag. They're now their own message types:
+
+```go
+// Before:
+case tea.KeyMsg:
+ if msg.Paste {
+ m.text += string(msg.Runes)
+ }
+
+// After:
+case tea.PasteMsg:
+ m.text += msg.Content
+case tea.PasteStartMsg:
+ // paste started
+case tea.PasteEndMsg:
+ // paste ended
+```
+
+## Mouse Messages
+
+### `tea.MouseMsg` is now an interface
+
+In v1, `tea.MouseMsg` was a struct with `X`, `Y`, `Button`, etc. In v2, it's an **interface**. You get the coordinates by calling `msg.Mouse()`:
+
+```go
+// Before:
+case tea.MouseMsg:
+ x, y := msg.X, msg.Y
+
+// After:
+case tea.MouseMsg:
+ mouse := msg.Mouse()
+ x, y := mouse.X, mouse.Y
+```
+
+### Mouse events are split by type
+
+Instead of checking `msg.Action`, match on specific message types:
+
+```go
+// Before:
+case tea.MouseMsg:
+ if msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
+ // left click
+ }
+
+// After:
+case tea.MouseClickMsg:
+ if msg.Button == tea.MouseLeft {
+ // left click
+ }
+case tea.MouseReleaseMsg:
+ // release
+case tea.MouseWheelMsg:
+ // scroll
+case tea.MouseMotionMsg:
+ // movement
+```
+
+### Button constants renamed
+
+| v1 | v2 |
+|---|---|
+| `tea.MouseButtonLeft` | `tea.MouseLeft` |
+| `tea.MouseButtonRight` | `tea.MouseRight` |
+| `tea.MouseButtonMiddle` | `tea.MouseMiddle` |
+| `tea.MouseButtonWheelUp` | `tea.MouseWheelUp` |
+| `tea.MouseButtonWheelDown` | `tea.MouseWheelDown` |
+| `tea.MouseButtonWheelLeft` | `tea.MouseWheelLeft` |
+| `tea.MouseButtonWheelRight` | `tea.MouseWheelRight` |
+
+### `tea.MouseEvent` → `tea.Mouse`
+
+The `MouseEvent` struct is gone. The new `Mouse` struct has `X`, `Y`, `Button`, and `Mod` fields.
+
+### Mouse mode is now a View field
+
+```go
+// Before:
+p := tea.NewProgram(model{}, tea.WithMouseCellMotion())
+
+// After:
+func (m model) View() tea.View {
+ v := tea.NewView("...")
+ v.MouseMode = tea.MouseModeCellMotion
+ return v
+}
+```
+
+## Removed Program Options
+
+These options no longer exist. They all moved to View fields.
+
+| Removed Option | Do This Instead |
+|---|---|
+| `tea.WithAltScreen()` | `view.AltScreen = true` |
+| `tea.WithMouseCellMotion()` | `view.MouseMode = tea.MouseModeCellMotion` |
+| `tea.WithMouseAllMotion()` | `view.MouseMode = tea.MouseModeAllMotion` |
+| `tea.WithReportFocus()` | `view.ReportFocus = true` |
+| `tea.WithoutBracketedPaste()` | `view.DisableBracketedPasteMode = true` |
+| `tea.WithInputTTY()` | Just remove it — v2 always opens the TTY for input automatically |
+| `tea.WithANSICompressor()` | Just remove it — the new renderer handles optimization automatically |
+
+## Removed Commands
+
+These commands no longer exist. Set the corresponding View field instead.
+
+| Removed Command | Do This Instead |
+|---|---|
+| `tea.EnterAltScreen` | `view.AltScreen = true` |
+| `tea.ExitAltScreen` | `view.AltScreen = false` |
+| `tea.EnableMouseCellMotion` | `view.MouseMode = tea.MouseModeCellMotion` |
+| `tea.EnableMouseAllMotion` | `view.MouseMode = tea.MouseModeAllMotion` |
+| `tea.DisableMouse` | `view.MouseMode = tea.MouseModeNone` |
+| `tea.HideCursor` | `view.Cursor = nil` |
+| `tea.ShowCursor` | `view.Cursor = &tea.Cursor{...}` or `tea.NewCursor(x, y)` |
+| `tea.EnableBracketedPaste` | `view.DisableBracketedPasteMode = false` |
+| `tea.DisableBracketedPaste` | `view.DisableBracketedPasteMode = true` |
+| `tea.EnableReportFocus` | `view.ReportFocus = true` |
+| `tea.DisableReportFocus` | `view.ReportFocus = false` |
+| `tea.SetWindowTitle("...")` | `view.WindowTitle = "..."` |
+
+## Removed Program Methods
+
+These methods on `*Program` are gone.
+
+| Removed Method | Do This Instead |
+|---|---|
+| `p.Start()` | `p.Run()` |
+| `p.StartReturningModel()` | `p.Run()` |
+| `p.EnterAltScreen()` | `view.AltScreen = true` in `View()` |
+| `p.ExitAltScreen()` | `view.AltScreen = false` in `View()` |
+| `p.EnableMouseCellMotion()` | `view.MouseMode` in `View()` |
+| `p.DisableMouseCellMotion()` | `view.MouseMode = tea.MouseModeNone` in `View()` |
+| `p.EnableMouseAllMotion()` | `view.MouseMode` in `View()` |
+| `p.DisableMouseAllMotion()` | `view.MouseMode = tea.MouseModeNone` in `View()` |
+| `p.SetWindowTitle(...)` | `view.WindowTitle` in `View()` |
+
+## Renamed APIs
+
+| v1 | v2 | Notes |
+|---|---|---|
+| `tea.Sequentially(...)` | `tea.Sequence(...)` | `Sequentially` was already deprecated in v1 |
+| `tea.WindowSize()` | `tea.RequestWindowSize` | Now returns `Msg` directly, not a `Cmd` |
+
+## New Program Options
+
+These are new in v2:
+
+| Option | What It Does |
+|---|---|
+| `tea.WithColorProfile(p)` | Force a specific color profile (great for testing) |
+| `tea.WithWindowSize(w, h)` | Set initial terminal size (great for testing) |
+
+## Complete Before & After
+
+Here's a minimal but complete program showing the most common migration patterns side by side.
+
+**v1:**
+
+```go
+package main
+
+import (
+ "fmt"
+ "os"
+
+ tea "github.com/charmbracelet/bubbletea"
+)
+
+type model struct {
+ count int
+}
+
+func (m model) Init() tea.Cmd {
+ return nil
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+ switch msg := msg.(type) {
+ case tea.KeyMsg:
+ switch msg.String() {
+ case "q", "ctrl+c":
+ return m, tea.Quit
+ case " ":
+ m.count++
+ }
+ case tea.MouseMsg:
+ if msg.Action == tea.MouseActionPress && msg.Button == tea.MouseButtonLeft {
+ m.count++
+ }
+ }
+ return m, nil
+}
+
+func (m model) View() string {
+ return fmt.Sprintf("Count: %d\n\nSpace or click to increment. q to quit.\n", m.count)
+}
+
+func main() {
+ p := tea.NewProgram(model{}, tea.WithAltScreen(), tea.WithMouseCellMotion())
+ if _, err := p.Run(); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+}
+```
+
+**v2:**
+
+```go
+package main
+
+import (
+ "fmt"
+ "os"
+
+ tea "charm.land/bubbletea/v2"
+)
+
+type model struct {
+ count int
+}
+
+func (m model) Init() tea.Cmd {
+ return nil
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+ switch msg := msg.(type) {
+ case tea.KeyPressMsg:
+ switch msg.String() {
+ case "q", "ctrl+c":
+ return m, tea.Quit
+ case "space":
+ m.count++
+ }
+ case tea.MouseClickMsg:
+ if msg.Button == tea.MouseLeft {
+ m.count++
+ }
+ }
+ return m, nil
+}
+
+func (m model) View() tea.View {
+ v := tea.NewView(fmt.Sprintf("Count: %d\n\nSpace or click to increment. q to quit.\n", m.count))
+ v.AltScreen = true
+ v.MouseMode = tea.MouseModeCellMotion
+ return v
+}
+
+func main() {
+ p := tea.NewProgram(model{})
+ if _, err := p.Run(); err != nil {
+ fmt.Fprintln(os.Stderr, err)
+ os.Exit(1)
+ }
+}
+```
+
+Notice how the `NewProgram` call got simpler? All the terminal feature flags moved into `View()` where they belong.
+
+## Quick Reference
+
+A flat old → new lookup table. Handy for search-and-replace and LLM-assisted migration.
+
+### Import Paths
+
+| v1 | v2 |
+|---|---|
+| `github.com/charmbracelet/bubbletea` | `charm.land/bubbletea/v2` |
+| `github.com/charmbracelet/lipgloss` | `charm.land/lipgloss/v2` |
+
+### Model Interface
+
+| v1 | v2 |
+|---|---|
+| `View() string` | `View() tea.View` |
+
+### Key Events
+
+| v1 | v2 |
+|---|---|
+| `tea.KeyMsg` (struct) | `tea.KeyPressMsg` for presses, `tea.KeyMsg` (interface) for both |
+| `msg.Type` | `msg.Code` |
+| `msg.Runes` | `msg.Text` (string, not `[]rune`) |
+| `msg.Alt` | `msg.Mod.Contains(tea.ModAlt)` |
+| `tea.KeyRune` | check `len(msg.Text) > 0` |
+| `tea.KeyCtrlC` | `msg.Code == 'c' && msg.Mod == tea.ModCtrl` or `msg.String() == "ctrl+c"` |
+| `case " ":` (space) | `case "space":` |
+
+### Mouse Events
+
+| v1 | v2 |
+|---|---|
+| `tea.MouseMsg` (struct) | `tea.MouseMsg` (interface) — call `.Mouse()` for the data |
+| `tea.MouseEvent` | `tea.Mouse` |
+| `tea.MouseButtonLeft` | `tea.MouseLeft` |
+| `tea.MouseButtonRight` | `tea.MouseRight` |
+| `tea.MouseButtonMiddle` | `tea.MouseMiddle` |
+| `tea.MouseButtonWheelUp` | `tea.MouseWheelUp` |
+| `tea.MouseButtonWheelDown` | `tea.MouseWheelDown` |
+| `msg.X`, `msg.Y` (direct) | `msg.Mouse().X`, `msg.Mouse().Y` |
+
+### Options → View Fields
+
+| v1 Option | v2 View Field |
+|---|---|
+| `tea.WithAltScreen()` | `view.AltScreen = true` |
+| `tea.WithMouseCellMotion()` | `view.MouseMode = tea.MouseModeCellMotion` |
+| `tea.WithMouseAllMotion()` | `view.MouseMode = tea.MouseModeAllMotion` |
+| `tea.WithReportFocus()` | `view.ReportFocus = true` |
+| `tea.WithoutBracketedPaste()` | `view.DisableBracketedPasteMode = true` |
+
+### Commands → View Fields
+
+| v1 Command | v2 View Field |
+|---|---|
+| `tea.EnterAltScreen` / `tea.ExitAltScreen` | `view.AltScreen = true/false` |
+| `tea.EnableMouseCellMotion` | `view.MouseMode = tea.MouseModeCellMotion` |
+| `tea.EnableMouseAllMotion` | `view.MouseMode = tea.MouseModeAllMotion` |
+| `tea.DisableMouse` | `view.MouseMode = tea.MouseModeNone` |
+| `tea.HideCursor` / `tea.ShowCursor` | `view.Cursor = nil` / `view.Cursor = &tea.Cursor{...}` |
+| `tea.EnableBracketedPaste` / `tea.DisableBracketedPaste` | `view.DisableBracketedPasteMode = false/true` |
+| `tea.EnableReportFocus` / `tea.DisableReportFocus` | `view.ReportFocus = true/false` |
+| `tea.SetWindowTitle("...")` | `view.WindowTitle = "..."` |
+
+### Removed Options (No Replacement Needed)
+
+| v1 Option | What Happened |
+|---|---|
+| `tea.WithInputTTY()` | v2 always opens the TTY for input automatically |
+| `tea.WithANSICompressor()` | The new renderer handles optimization automatically |
+
+### Removed Program Methods
+
+| v1 Method | v2 Replacement |
+|---|---|
+| `p.Start()` | `p.Run()` |
+| `p.StartReturningModel()` | `p.Run()` |
+| `p.EnterAltScreen()` | `view.AltScreen = true` in `View()` |
+| `p.ExitAltScreen()` | `view.AltScreen = false` in `View()` |
+| `p.EnableMouseCellMotion()` | `view.MouseMode` in `View()` |
+| `p.DisableMouseCellMotion()` | `view.MouseMode = tea.MouseModeNone` in `View()` |
+| `p.EnableMouseAllMotion()` | `view.MouseMode` in `View()` |
+| `p.DisableMouseAllMotion()` | `view.MouseMode = tea.MouseModeNone` in `View()` |
+| `p.SetWindowTitle(...)` | `view.WindowTitle` in `View()` |
+
+### Other Renames
+
+| v1 | v2 |
+|---|---|
+| `tea.Sequentially(...)` | `tea.Sequence(...)` |
+| `tea.WindowSize()` | `tea.RequestWindowSize` (now returns `Msg`, not `Cmd`) |
+
+### New Program Options
+
+| Option | Description |
+|---|---|
+| `tea.WithColorProfile(p)` | Force a specific color profile |
+| `tea.WithWindowSize(w, h)` | Set initial window size (great for testing) |
+
+## Feedback
+
+Have thoughts on the v2 upgrade? We'd _love_ to hear about it. Let us know on…
+
+- [Discord](https://charm.land/chat)
+- [Matrix](https://charm.land/matrix)
+- [Email](mailto:vt100@charm.land)
+
+---
+
+Part of [Charm](https://charm.land).
+
+
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
diff --git a/vendor/charm.land/bubbletea/v2/clipboard.go b/vendor/charm.land/bubbletea/v2/clipboard.go
new file mode 100644
index 000000000..237a589ed
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/clipboard.go
@@ -0,0 +1,70 @@
+package tea
+
+// ClipboardMsg is a clipboard read message event. This message is emitted when
+// a terminal receives an OSC52 clipboard read message event.
+type ClipboardMsg struct {
+ Content string
+ Selection byte
+}
+
+// Clipboard returns the clipboard selection type. This will be one of the
+// following values:
+//
+// - c: System clipboard.
+// - p: Primary clipboard (X11/Wayland only).
+func (e ClipboardMsg) Clipboard() byte {
+ return e.Selection
+}
+
+// String returns the string representation of the clipboard message.
+func (e ClipboardMsg) String() string {
+ return e.Content
+}
+
+// setClipboardMsg is an internal message used to set the system clipboard
+// using OSC52.
+type setClipboardMsg string
+
+// SetClipboard produces a command that sets the system clipboard using OSC52.
+// Note that OSC52 is not supported in all terminals.
+func SetClipboard(s string) Cmd {
+ return func() Msg {
+ return setClipboardMsg(s)
+ }
+}
+
+// readClipboardMsg is an internal message used to read the system clipboard
+// using OSC52.
+type readClipboardMsg struct{}
+
+// ReadClipboard produces a command that reads the system clipboard using OSC52.
+// Note that OSC52 is not supported in all terminals.
+func ReadClipboard() Msg {
+ return readClipboardMsg{}
+}
+
+// setPrimaryClipboardMsg is an internal message used to set the primary
+// clipboard using OSC52.
+type setPrimaryClipboardMsg string
+
+// SetPrimaryClipboard produces a command that sets the primary clipboard using
+// OSC52. Primary clipboard selection is a feature present in X11 and Wayland
+// only.
+// Note that OSC52 is not supported in all terminals.
+func SetPrimaryClipboard(s string) Cmd {
+ return func() Msg {
+ return setPrimaryClipboardMsg(s)
+ }
+}
+
+// readPrimaryClipboardMsg is an internal message used to read the primary
+// clipboard using OSC52.
+type readPrimaryClipboardMsg struct{}
+
+// ReadPrimaryClipboard produces a command that reads the primary clipboard
+// using OSC52. Primary clipboard selection is a feature present in X11 and
+// Wayland only.
+// Note that OSC52 is not supported in all terminals.
+func ReadPrimaryClipboard() Msg {
+ return readPrimaryClipboardMsg{}
+}
diff --git a/vendor/charm.land/bubbletea/v2/color.go b/vendor/charm.land/bubbletea/v2/color.go
new file mode 100644
index 000000000..54514e4b3
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/color.go
@@ -0,0 +1,91 @@
+package tea
+
+import (
+ "image/color"
+
+ uv "github.com/charmbracelet/ultraviolet"
+)
+
+// backgroundColorMsg is a message that requests the terminal background color.
+type backgroundColorMsg struct{}
+
+// RequestBackgroundColor is a command that requests the terminal background color.
+func RequestBackgroundColor() Msg {
+ return backgroundColorMsg{}
+}
+
+// foregroundColorMsg is a message that requests the terminal foreground color.
+type foregroundColorMsg struct{}
+
+// RequestForegroundColor is a command that requests the terminal foreground color.
+func RequestForegroundColor() Msg {
+ return foregroundColorMsg{}
+}
+
+// cursorColorMsg is a message that requests the terminal cursor color.
+type cursorColorMsg struct{}
+
+// RequestCursorColor is a command that requests the terminal cursor color.
+func RequestCursorColor() Msg {
+ return cursorColorMsg{}
+}
+
+// ForegroundColorMsg represents a foreground color message. This message is
+// emitted when the program requests the terminal foreground color with the
+// [RequestForegroundColor] Cmd.
+type ForegroundColorMsg struct{ color.Color }
+
+// String returns the hex representation of the color.
+func (e ForegroundColorMsg) String() string {
+ return uv.ForegroundColorEvent(e).String()
+}
+
+// IsDark returns whether the color is dark.
+func (e ForegroundColorMsg) IsDark() bool {
+ return uv.ForegroundColorEvent(e).IsDark()
+}
+
+// BackgroundColorMsg represents a background color message. This message is
+// emitted when the program requests the terminal background color with the
+// [RequestBackgroundColor] Cmd.
+//
+// This is commonly used in [Update.Init] to get the terminal background color
+// for style definitions. For that you'll want to call
+// [BackgroundColorMsg.IsDark] to determine if the color is dark or light. For
+// example:
+//
+// func (m Model) Init() (Model, Cmd) {
+// return m, RequestBackgroundColor()
+// }
+//
+// func (m Model) Update(msg Msg) (Model, Cmd) {
+// switch msg := msg.(type) {
+// case BackgroundColorMsg:
+// m.styles = newStyles(msg.IsDark())
+// }
+// }
+type BackgroundColorMsg struct{ color.Color }
+
+// String returns the hex representation of the color.
+func (e BackgroundColorMsg) String() string {
+ return uv.BackgroundColorEvent(e).String()
+}
+
+// IsDark returns whether the color is dark.
+func (e BackgroundColorMsg) IsDark() bool {
+ return uv.BackgroundColorEvent(e).IsDark()
+}
+
+// CursorColorMsg represents a cursor color change message. This message is
+// emitted when the program requests the terminal cursor color.
+type CursorColorMsg struct{ color.Color }
+
+// String returns the hex representation of the color.
+func (e CursorColorMsg) String() string {
+ return uv.CursorColorEvent(e).String()
+}
+
+// IsDark returns whether the color is dark.
+func (e CursorColorMsg) IsDark() bool {
+ return uv.CursorColorEvent(e).IsDark()
+}
diff --git a/vendor/charm.land/bubbletea/v2/commands.go b/vendor/charm.land/bubbletea/v2/commands.go
new file mode 100644
index 000000000..4497c3a38
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/commands.go
@@ -0,0 +1,175 @@
+package tea
+
+import (
+ "time"
+)
+
+// Batch performs a bunch of commands concurrently with no ordering guarantees
+// about the results. Use a Batch to return several commands.
+//
+// Example:
+//
+// func (m model) Init() (Model, Cmd) {
+// return m, tea.Batch(someCommand, someOtherCommand)
+// }
+func Batch(cmds ...Cmd) Cmd {
+ return compactCmds[BatchMsg](cmds)
+}
+
+// BatchMsg is a message used to perform a bunch of commands concurrently with
+// no ordering guarantees. You can send a BatchMsg with Batch.
+type BatchMsg []Cmd
+
+// Sequence runs the given commands one at a time, in order. Contrast this with
+// Batch, which runs commands concurrently.
+func Sequence(cmds ...Cmd) Cmd {
+ return compactCmds[sequenceMsg](cmds)
+}
+
+// sequenceMsg is used internally to run the given commands in order.
+type sequenceMsg []Cmd
+
+// compactCmds ignores any nil commands in cmds, and returns the most direct
+// command possible. That is, considering the non-nil commands, if there are
+// none it returns nil, if there is exactly one it returns that command
+// directly, else it returns the non-nil commands as type T.
+func compactCmds[T ~[]Cmd](cmds []Cmd) Cmd {
+ var validCmds []Cmd
+ for _, c := range cmds {
+ if c == nil {
+ continue
+ }
+ validCmds = append(validCmds, c)
+ }
+ switch len(validCmds) {
+ case 0:
+ return nil
+ case 1:
+ return validCmds[0]
+ default:
+ return func() Msg {
+ return T(validCmds)
+ }
+ }
+}
+
+// Every is a command that ticks in sync with the system clock. So, if you
+// wanted to tick with the system clock every second, minute or hour you
+// could use this. It's also handy for having different things tick in sync.
+//
+// Because we're ticking with the system clock the tick will likely not run for
+// the entire specified duration. For example, if we're ticking for one minute
+// and the clock is at 12:34:20 then the next tick will happen at 12:35:00, 40
+// seconds later.
+//
+// To produce the command, pass a duration and a function which returns
+// a message containing the time at which the tick occurred.
+//
+// type TickMsg time.Time
+//
+// cmd := Every(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+//
+// Beginners' note: Every sends a single message and won't automatically
+// dispatch messages at an interval. To do that, you'll want to return another
+// Every command after receiving your tick message. For example:
+//
+// type TickMsg time.Time
+//
+// // Send a message every second.
+// func tickEvery() Cmd {
+// return Every(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+// }
+//
+// func (m model) Init() (Model, Cmd) {
+// // Start ticking.
+// return m, tickEvery()
+// }
+//
+// func (m model) Update(msg Msg) (Model, Cmd) {
+// switch msg.(type) {
+// case TickMsg:
+// // Return your Every command again to loop.
+// return m, tickEvery()
+// }
+// return m, nil
+// }
+//
+// Every is analogous to Tick in the Elm Architecture.
+func Every(duration time.Duration, fn func(time.Time) Msg) Cmd {
+ n := time.Now()
+ d := n.Truncate(duration).Add(duration).Sub(n)
+ t := time.NewTimer(d)
+ return func() Msg {
+ ts := <-t.C
+ t.Stop()
+ for len(t.C) > 0 {
+ <-t.C
+ }
+ return fn(ts)
+ }
+}
+
+// Tick produces a command at an interval independent of the system clock at
+// the given duration. That is, the timer begins precisely when invoked,
+// and runs for its entire duration.
+//
+// To produce the command, pass a duration and a function which returns
+// a message containing the time at which the tick occurred.
+//
+// type TickMsg time.Time
+//
+// cmd := Tick(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+//
+// Beginners' note: Tick sends a single message and won't automatically
+// dispatch messages at an interval. To do that, you'll want to return another
+// Tick command after receiving your tick message. For example:
+//
+// type TickMsg time.Time
+//
+// func doTick() Cmd {
+// return Tick(time.Second, func(t time.Time) Msg {
+// return TickMsg(t)
+// })
+// }
+//
+// func (m model) Init() (Model, Cmd) {
+// // Start ticking.
+// return m, doTick()
+// }
+//
+// func (m model) Update(msg Msg) (Model, Cmd) {
+// switch msg.(type) {
+// case TickMsg:
+// // Return your Tick command again to loop.
+// return m, doTick()
+// }
+// return m, nil
+// }
+func Tick(d time.Duration, fn func(time.Time) Msg) Cmd {
+ t := time.NewTimer(d)
+ return func() Msg {
+ ts := <-t.C
+ t.Stop()
+ for len(t.C) > 0 {
+ <-t.C
+ }
+ return fn(ts)
+ }
+}
+
+type windowSizeMsg struct{}
+
+// RequestWindowSize is a command that queries the terminal for its current
+// size. It delivers the results to Update via a [WindowSizeMsg]. Keep in mind
+// that WindowSizeMsgs will automatically be delivered to Update when the
+// [Program] starts and when the window dimensions change so in many cases you
+// will not need to explicitly invoke this command.
+func RequestWindowSize() Msg {
+ return windowSizeMsg{}
+}
diff --git a/vendor/charm.land/bubbletea/v2/cursed_renderer.go b/vendor/charm.land/bubbletea/v2/cursed_renderer.go
new file mode 100644
index 000000000..8eaafb23d
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/cursed_renderer.go
@@ -0,0 +1,854 @@
+package tea
+
+import (
+ "bytes"
+ "fmt"
+ "image/color"
+ "io"
+ "runtime"
+ "strings"
+ "sync"
+
+ "github.com/charmbracelet/colorprofile"
+ uv "github.com/charmbracelet/ultraviolet"
+ "github.com/charmbracelet/x/ansi"
+ "github.com/lucasb-eyer/go-colorful"
+)
+
+type cursedRenderer struct {
+ w io.Writer
+ buf bytes.Buffer // updates buffer to be flushed to [w]
+ scr *uv.TerminalRenderer
+ cellbuf uv.ScreenBuffer
+ lastView *View
+ env []string
+ term string // the terminal type $TERM
+ width, height int
+ mu sync.Mutex
+ profile colorprofile.Profile
+ logger uv.Logger
+ view View
+ hardTabs bool // whether to use hard tabs to optimize cursor movements
+ backspace bool // whether to use backspace to optimize cursor movements
+ mapnl bool
+ syncdUpdates bool // whether to use synchronized output mode for updates
+ starting bool // indicates whether the renderer is starting after being stopped
+}
+
+var _ renderer = &cursedRenderer{}
+
+func newCursedRenderer(w io.Writer, env []string, width, height int) (s *cursedRenderer) {
+ s = new(cursedRenderer)
+ s.w = w
+ s.env = env
+ s.term = uv.Environ(env).Getenv("TERM")
+ s.width, s.height = width, height // This needs to happen before [cursedRenderer.reset].
+ s.cellbuf = uv.NewScreenBuffer(s.width, s.height)
+ reset(s)
+ return
+}
+
+// setLogger sets the logger for the renderer.
+func (s *cursedRenderer) setLogger(logger uv.Logger) {
+ s.mu.Lock()
+ s.logger = logger
+ s.mu.Unlock()
+}
+
+// setOptimizations sets the cursor movement optimizations.
+func (s *cursedRenderer) setOptimizations(hardTabs, backspace, mapnl bool) {
+ s.mu.Lock()
+ s.hardTabs = hardTabs
+ s.backspace = backspace
+ s.mapnl = mapnl
+ if s.hardTabs {
+ s.scr.SetTabStops(s.width)
+ } else {
+ s.scr.SetTabStops(-1)
+ }
+ s.scr.SetBackspace(s.backspace)
+ s.scr.SetMapNewline(s.mapnl)
+ s.mu.Unlock()
+}
+
+// start implements renderer.
+func (s *cursedRenderer) start() {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ // Mark that we're starting. This is used to restore some state when
+ // starting the renderer again after it was stopped.
+ s.starting = true
+
+ if s.lastView == nil {
+ return
+ }
+
+ if s.lastView.AltScreen {
+ enableAltScreen(s, true, true)
+ }
+ enableTextCursor(s, s.lastView.Cursor != nil)
+ if s.lastView.Cursor != nil {
+ if s.lastView.Cursor.Color != nil {
+ col, ok := colorful.MakeColor(s.lastView.Cursor.Color)
+ if ok {
+ _, _ = s.scr.WriteString(ansi.SetCursorColor(col.Hex()))
+ }
+ }
+ curStyle := encodeCursorStyle(s.lastView.Cursor.Shape, s.lastView.Cursor.Blink)
+ if curStyle != 0 && curStyle != 1 {
+ _, _ = s.scr.WriteString(ansi.SetCursorStyle(curStyle))
+ }
+ }
+ if s.lastView.ForegroundColor != nil {
+ col, ok := colorful.MakeColor(s.lastView.ForegroundColor)
+ if ok {
+ _, _ = s.scr.WriteString(ansi.SetForegroundColor(col.Hex()))
+ }
+ }
+ if s.lastView.BackgroundColor != nil {
+ col, ok := colorful.MakeColor(s.lastView.BackgroundColor)
+ if ok {
+ _, _ = s.scr.WriteString(ansi.SetBackgroundColor(col.Hex()))
+ }
+ }
+ if !s.lastView.DisableBracketedPasteMode {
+ _, _ = s.scr.WriteString(ansi.SetModeBracketedPaste)
+ }
+ if s.lastView.ReportFocus {
+ _, _ = s.scr.WriteString(ansi.SetModeFocusEvent)
+ }
+ switch s.lastView.MouseMode {
+ case MouseModeNone:
+ case MouseModeCellMotion:
+ _, _ = s.scr.WriteString(ansi.SetModeMouseButtonEvent + ansi.SetModeMouseExtSgr)
+ case MouseModeAllMotion:
+ _, _ = s.scr.WriteString(ansi.SetModeMouseAnyEvent + ansi.SetModeMouseExtSgr)
+ }
+ if s.lastView.WindowTitle != "" {
+ _, _ = s.scr.WriteString(ansi.SetWindowTitle(s.lastView.WindowTitle))
+ }
+ if s.lastView.ProgressBar != nil {
+ setProgressBar(s, s.lastView.ProgressBar)
+ }
+ // Enable modifyOtherKeys and Kitty keyboard protocol.
+ // Both can coexist; terminals ignore what they don't support.
+ _, _ = s.scr.WriteString(ansi.SetModifyOtherKeys2)
+
+ kittyFlags := keyboardEnhancementsFlags(s.lastView.KeyboardEnhancements)
+ _, _ = s.scr.WriteString(ansi.KittyKeyboard(kittyFlags, 1))
+}
+
+// close implements renderer.
+func (s *cursedRenderer) close() (err error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ // Exit the altScreen and show cursor before closing. It's important that
+ // we don't change the [cursedRenderer] altScreen and cursorHidden states
+ // so that we can restore them when we start the renderer again. This is
+ // used when the user suspends the program and then resumes it.
+ if lv := s.lastView; lv != nil { //nolint:nestif
+ // NOTE: The Kitty keyboard specs specify that the terminal should have
+ // two registries for the main and alt screens. We disable keyboard
+ // enhancements whenever we enter/exit alt screen mode in
+ // [cursedRenderer.flush].
+ // Here, we reset the keyboard protocol of the last screen used
+ // assuming the other screen is already reset when we switched screens.
+ _, _ = s.buf.WriteString(ansi.ResetModifyOtherKeys)
+ _, _ = s.buf.WriteString(ansi.KittyKeyboard(0, 1))
+
+ // Go to the bottom of the screen.
+ // We need to go to the bottom of the screen regardless of whether
+ // we're in alt screen mode or not to avoid leaving the cursor in the
+ // middle in terminals that don't support alt screen mode.
+ s.scr.MoveTo(0, s.cellbuf.Height()-1)
+ _ = s.scr.Flush() // we need to flush to write the cursor movement
+ if lv.AltScreen {
+ enableAltScreen(s, false, true)
+ } else {
+ _, _ = s.scr.WriteString(ansi.EraseScreenBelow)
+ }
+ if lv.Cursor == nil {
+ enableTextCursor(s, true)
+ }
+ if !lv.DisableBracketedPasteMode {
+ _, _ = s.scr.WriteString(ansi.ResetModeBracketedPaste)
+ }
+ if lv.ReportFocus {
+ _, _ = s.scr.WriteString(ansi.ResetModeFocusEvent)
+ }
+ switch lv.MouseMode {
+ case MouseModeNone:
+ case MouseModeCellMotion, MouseModeAllMotion:
+ _, _ = s.scr.WriteString(ansi.ResetModeMouseButtonEvent +
+ ansi.ResetModeMouseAnyEvent +
+ ansi.ResetModeMouseExtSgr)
+ }
+
+ if lv.WindowTitle != "" {
+ // Clear the window title if it was set.
+ _, _ = s.scr.WriteString(ansi.SetWindowTitle(""))
+ }
+ if lc := lv.Cursor; lc != nil {
+ curShape := encodeCursorStyle(lc.Shape, lc.Blink)
+ if curShape != 0 && curShape != 1 {
+ // Reset the cursor style to default if it was set to something other
+ // blinking block.
+ _, _ = s.scr.WriteString(ansi.SetCursorStyle(0))
+ }
+
+ if lc.Color != nil {
+ _, _ = s.scr.WriteString(ansi.ResetCursorColor)
+ }
+ }
+
+ if lv.BackgroundColor != nil {
+ _, _ = s.scr.WriteString(ansi.ResetBackgroundColor)
+ }
+ if lv.ForegroundColor != nil {
+ _, _ = s.scr.WriteString(ansi.ResetForegroundColor)
+ }
+ if lv.ProgressBar != nil && lv.ProgressBar.State != ProgressBarNone {
+ _, _ = s.scr.WriteString(ansi.ResetProgressBar)
+ }
+ }
+
+ if s.cellbuf.Method == ansi.GraphemeWidth {
+ // Make sure to turn off Unicode mode (2027)
+ _, _ = s.scr.WriteString(ansi.ResetModeUnicodeCore)
+ }
+
+ if err := s.scr.Flush(); err != nil {
+ return fmt.Errorf("bubbletea: error closing screen writer: %w", err)
+ }
+
+ if s.buf.Len() > 0 {
+ if s.logger != nil {
+ s.logger.Printf("output: %q", s.buf.String())
+ }
+ if _, err := io.Copy(s.w, &s.buf); err != nil {
+ return fmt.Errorf("bubbletea: error writing to screen: %w", err)
+ }
+ s.buf.Reset()
+ }
+
+ x, y := s.scr.Position()
+
+ // We want to clear the renderer state but not the cursor position. This is
+ // because we might be putting the tea process in the background, run some
+ // other process, and then return to the tea process. We want to keep the
+ // cursor position so that we can continue where we left off.
+ reset(s)
+ s.scr.SetPosition(x, y)
+
+ return nil
+}
+
+// writeString implements renderer.
+func (s *cursedRenderer) writeString(str string) (int, error) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ return s.scr.WriteString(str) //nolint:wrapcheck
+}
+
+// flush implements renderer.
+func (s *cursedRenderer) flush(closing bool) error {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ view := s.view
+ frameArea := uv.Rect(0, 0, s.width, s.height)
+ if len(view.Content) == 0 {
+ // If the component is nil, we should clear the screen buffer.
+ frameArea.Max.Y = 0
+ }
+
+ content := uv.NewStyledString(view.Content)
+ if !view.AltScreen {
+ // We need to resizes the screen based on the frame height and
+ // terminal width. This is because the frame height can change based on
+ // the content of the frame. For example, if the frame contains a list
+ // of items, the height of the frame will be the number of items in the
+ // list. This is different from the alt screen buffer, which has a
+ // fixed height and width.
+ frameHeight := content.Height()
+ if frameHeight != frameArea.Dy() {
+ frameArea.Max.Y = frameHeight
+ }
+ }
+
+ // Restore tab stops if we have tab optimizations enabled.
+ if s.starting && s.hardTabs {
+ _, _ = s.scr.WriteString(ansi.SetTabEvery8Columns)
+ }
+
+ if !s.starting && !closing && s.lastView != nil && viewEquals(s.lastView, &view) && frameArea == s.cellbuf.Bounds() {
+ // No changes, nothing to do.
+ return nil
+ }
+
+ // We're no longer starting.
+ s.starting = false
+
+ if frameArea != s.cellbuf.Bounds() {
+ s.scr.Erase() // Force a full redraw to avoid artifacts.
+
+ // We need to reset the touched lines buffer to match the new height.
+ s.cellbuf.Touched = nil
+
+ // Resize the screen buffer to match the frame area. This is necessary
+ // to ensure that the screen buffer is the same size as the frame area
+ // and to avoid rendering issues when the frame area is smaller than
+ // the screen buffer.
+ s.cellbuf.Resize(frameArea.Dx(), frameArea.Dy())
+ }
+
+ // Clear our screen buffer before copying the new frame into it to ensure
+ // we erase any old content.
+ s.cellbuf.Clear()
+ content.Draw(s.cellbuf, s.cellbuf.Bounds())
+
+ // If the frame height is greater than the screen height, we drop the
+ // lines from the top of the buffer.
+ if frameHeight := frameArea.Dy(); frameHeight > s.height {
+ s.cellbuf.Lines = s.cellbuf.Lines[frameHeight-s.height:]
+ }
+
+ // Alt screen mode.
+ shouldUpdateAltScreen := (s.lastView == nil && view.AltScreen) || (s.lastView != nil && s.lastView.AltScreen != view.AltScreen)
+ if shouldUpdateAltScreen {
+ // We want to enter/exit altscreen mode but defer writing the actual
+ // sequences until we flush the rest of the updates. This is because we
+ // control the cursor visibility and we need to ensure that happens
+ // after entering/exiting alt screen mode. Some terminals have
+ // different cursor visibility states for main and alt screen modes and
+ // this ensures we handle that correctly.
+ enableAltScreen(s, view.AltScreen, false)
+ }
+
+ // bracketed paste mode.
+ if s.lastView == nil || view.DisableBracketedPasteMode != s.lastView.DisableBracketedPasteMode {
+ if !view.DisableBracketedPasteMode {
+ _, _ = s.scr.WriteString(ansi.SetModeBracketedPaste)
+ } else if s.lastView != nil {
+ _, _ = s.scr.WriteString(ansi.ResetModeBracketedPaste)
+ }
+ }
+
+ // report focus events mode.
+ if s.lastView == nil || s.lastView.ReportFocus != view.ReportFocus {
+ if view.ReportFocus {
+ _, _ = s.scr.WriteString(ansi.SetModeFocusEvent)
+ } else if s.lastView != nil {
+ _, _ = s.scr.WriteString(ansi.ResetModeFocusEvent)
+ }
+ }
+
+ // mouse events mode.
+ if s.lastView == nil || view.MouseMode != s.lastView.MouseMode {
+ switch view.MouseMode {
+ case MouseModeNone:
+ if s.lastView != nil && s.lastView.MouseMode != MouseModeNone {
+ _, _ = s.scr.WriteString(ansi.ResetModeMouseButtonEvent +
+ ansi.ResetModeMouseAnyEvent +
+ ansi.ResetModeMouseExtSgr)
+ }
+ case MouseModeCellMotion:
+ if s.lastView != nil && s.lastView.MouseMode == MouseModeAllMotion {
+ _, _ = s.scr.WriteString(ansi.ResetModeMouseAnyEvent)
+ }
+ _, _ = s.scr.WriteString(ansi.SetModeMouseButtonEvent + ansi.SetModeMouseExtSgr)
+ case MouseModeAllMotion:
+ if s.lastView != nil && s.lastView.MouseMode == MouseModeCellMotion {
+ _, _ = s.scr.WriteString(ansi.ResetModeMouseButtonEvent)
+ }
+ _, _ = s.scr.WriteString(ansi.SetModeMouseAnyEvent + ansi.SetModeMouseExtSgr)
+ }
+ }
+
+ // Set window title.
+ if s.lastView == nil || view.WindowTitle != s.lastView.WindowTitle {
+ if s.lastView != nil || view.WindowTitle != "" {
+ _, _ = s.scr.WriteString(ansi.SetWindowTitle(view.WindowTitle))
+ }
+ }
+
+ // kitty keyboard protocol
+ if s.lastView == nil || view.KeyboardEnhancements != s.lastView.KeyboardEnhancements ||
+ view.AltScreen != s.lastView.AltScreen {
+ // NOTE: We need to reset the keyboard protocol when switching
+ // between main and alt screen. This is because the specs specify
+ // two different states for the main and alt screen.
+
+ // Enable modifyOtherKeys and Kitty keyboard protocol.
+ _, _ = s.scr.WriteString(ansi.SetModifyOtherKeys2)
+
+ kittyFlags := keyboardEnhancementsFlags(view.KeyboardEnhancements)
+ _, _ = s.scr.WriteString(ansi.KittyKeyboard(kittyFlags, 1))
+ if !closing {
+ // Request keyboard enhancements when they change
+ _, _ = s.scr.WriteString(ansi.RequestKittyKeyboard)
+ }
+ }
+
+ // Set terminal colors.
+ var (
+ cc, lcc color.Color
+ lfg, lbg color.Color
+ )
+ if view.Cursor != nil {
+ cc = view.Cursor.Color
+ }
+ if s.lastView != nil {
+ if s.lastView.Cursor != nil {
+ lcc = s.lastView.Cursor.Color
+ }
+ lfg = s.lastView.ForegroundColor
+ lbg = s.lastView.BackgroundColor
+ }
+ for _, c := range []struct {
+ newColor color.Color
+ oldColor color.Color
+ reset string
+ setter func(string) string
+ }{
+ {newColor: cc, oldColor: lcc, reset: ansi.ResetCursorColor, setter: ansi.SetCursorColor},
+ {newColor: view.ForegroundColor, oldColor: lfg, reset: ansi.ResetForegroundColor, setter: ansi.SetForegroundColor},
+ {newColor: view.BackgroundColor, oldColor: lbg, reset: ansi.ResetBackgroundColor, setter: ansi.SetBackgroundColor},
+ } {
+ if c.newColor != c.oldColor {
+ if c.newColor == nil {
+ // Reset the color if it was set to nil.
+ _, _ = s.scr.WriteString(c.reset)
+ } else {
+ // Set the color.
+ col, ok := colorful.MakeColor(c.newColor)
+ if ok {
+ _, _ = s.scr.WriteString(c.setter(col.Hex()))
+ }
+ }
+ }
+ }
+
+ // Set cursor shape and blink if set.
+ var ccStyle, lcStyle int
+ var lcur *Cursor
+ ccur := view.Cursor
+ if lv := s.lastView; lv != nil {
+ lcur = lv.Cursor
+ }
+ if ccur != nil {
+ ccStyle = encodeCursorStyle(ccur.Shape, ccur.Blink)
+ }
+ if lcur != nil {
+ lcStyle = encodeCursorStyle(lcur.Shape, lcur.Blink)
+ }
+ if ccStyle != lcStyle {
+ _, _ = s.scr.WriteString(ansi.SetCursorStyle(ccStyle))
+ }
+
+ // Render progress bar if it's changed.
+ if (s.lastView == nil && view.ProgressBar != nil && view.ProgressBar.State != ProgressBarNone) ||
+ (s.lastView != nil && (s.lastView.ProgressBar == nil) != (view.ProgressBar == nil)) ||
+ (s.lastView != nil && s.lastView.ProgressBar != nil && view.ProgressBar != nil && *s.lastView.ProgressBar != *view.ProgressBar) {
+ // Render or clear the progress bar if it was added or removed.
+ setProgressBar(s, view.ProgressBar)
+ }
+
+ // Render and queue changes to the screen buffer.
+ s.scr.Render(s.cellbuf.RenderBuffer)
+
+ if cur := view.Cursor; cur != nil {
+ // MoveTo must come after [uv.TerminalRenderer.Render] because the
+ // cursor position might get updated during rendering.
+ s.scr.MoveTo(view.Cursor.X, view.Cursor.Y)
+ } else if !view.AltScreen {
+ // We don't want the cursor to be dangling at the end of the line in
+ // inline mode because it can cause unwanted line wraps in some
+ // terminals. So we move it to the beginning of the next line if
+ // necessary.
+ // This is only needed when the cursor is hidden because when it's
+ // visible, we already set its position above.
+ x, y := s.scr.Position()
+ if x >= s.width-1 {
+ s.scr.MoveTo(0, y)
+ }
+ }
+
+ if err := s.scr.Flush(); err != nil {
+ return fmt.Errorf("bubbletea: error flushing screen writer: %w", err)
+ }
+
+ // Check if we have any render updates to flush.
+ hasUpdates := s.buf.Len() > 0
+
+ // Cursor visibility.
+ didShowCursor := s.lastView != nil && s.lastView.Cursor != nil
+ showCursor := view.Cursor != nil
+ hideCursor := !showCursor
+ shouldUpdateCursorVis := (s.lastView == nil || didShowCursor != showCursor) || shouldUpdateAltScreen
+
+ // Build final output buffer with synchronized output or hide/show cursor
+ // updates. But first, enter/exit alt screen mode if needed.
+ //
+ // Here, we have two scenarios:
+ // 1. Synchronized output updates are supported. In this case, we want to
+ // wrap all updates, unless it's just a cursor visibility change, in
+ // synchronized output mode. This is because synchronized output mode
+ // takes care of rendering the updates atomically. In the case of
+ // just a cursor visibility change, we don't need to enter
+ // synchronized output mode because it's just a single sequence to
+ // flush out to the terminal.
+ //
+ // 2. We don't have synchronized output updates support. In this case, and
+ // if the cursor is visible or should be visible, we wrap the updates
+ // with hide/show cursor sequences to try and mitigate cursor
+ // flickering. This is terminal dependent and may still result in
+ // flickering in some terminals. It's the best effort we can do instead
+ // of showing the cursor flying around the screen during updates.
+
+ var buf bytes.Buffer
+ if shouldUpdateAltScreen {
+ // We always disable keyboard enhancements when switching screens
+ // because the terminal is expected to have two different keyboard
+ // registries for main and alt screens.
+ _, _ = buf.WriteString(ansi.ResetModifyOtherKeys)
+ _, _ = buf.WriteString(ansi.KittyKeyboard(0, 1))
+ if view.AltScreen {
+ // Entering alt screen mode.
+ buf.WriteString(ansi.SetModeAltScreenSaveCursor)
+ } else {
+ // Exiting alt screen mode.
+ buf.WriteString(ansi.ResetModeAltScreenSaveCursor)
+ }
+ }
+
+ if s.syncdUpdates {
+ if hasUpdates {
+ // We have synchronized output updates enabled.
+ buf.WriteString(ansi.SetModeSynchronizedOutput)
+ }
+ if shouldUpdateCursorVis && hideCursor {
+ // Do we need to update the cursor visibility to hidden? If so, do
+ // it here before writing any updates to the buffer.
+ _, _ = buf.WriteString(ansi.ResetModeTextCursorEnable)
+ }
+ } else if (shouldUpdateCursorVis && hideCursor) || (hasUpdates && showCursor && didShowCursor) {
+ _, _ = buf.WriteString(ansi.ResetModeTextCursorEnable)
+ }
+
+ if hasUpdates {
+ buf.Write(s.buf.Bytes())
+ }
+
+ if s.syncdUpdates {
+ if shouldUpdateCursorVis && showCursor {
+ // Do we need to update the cursor visibility to visible? If so, do
+ // it here after writing any updates to the buffer.
+ _, _ = buf.WriteString(ansi.SetModeTextCursorEnable)
+ }
+ if hasUpdates {
+ // Close synchronized output mode.
+ buf.WriteString(ansi.ResetModeSynchronizedOutput)
+ }
+ } else if (shouldUpdateCursorVis && showCursor) || (hasUpdates && showCursor && didShowCursor) {
+ _, _ = buf.WriteString(ansi.SetModeTextCursorEnable)
+ }
+
+ // Reset internal screen renderer buffer.
+ s.buf.Reset()
+
+ // If our updates flush buffer has content, write it to the output writer.
+ if buf.Len() > 0 {
+ if s.logger != nil {
+ s.logger.Printf("output: %q", buf.String())
+ }
+ if _, err := io.Copy(s.w, &buf); err != nil {
+ return fmt.Errorf("bubbletea: error flushing update to the writer: %w", err)
+ }
+ }
+
+ s.lastView = &view
+
+ return nil
+}
+
+// render implements renderer.
+func (s *cursedRenderer) render(v View) {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ s.view = v
+}
+
+// reset implements renderer.
+func (s *cursedRenderer) reset() {
+ s.mu.Lock()
+ reset(s)
+ s.mu.Unlock()
+}
+
+func reset(s *cursedRenderer) {
+ s.buf.Reset()
+ scr := uv.NewTerminalRenderer(&s.buf, s.env)
+ scr.SetColorProfile(s.profile)
+ scr.SetRelativeCursor(true) // Always start in inline mode
+ scr.SetFullscreen(false) // Always start in inline mode
+ if s.hardTabs {
+ scr.SetTabStops(s.width)
+ } else {
+ scr.SetTabStops(-1)
+ }
+ scr.SetBackspace(s.backspace)
+ scr.SetMapNewline(s.mapnl)
+ scr.SetScrollOptim(runtime.GOOS != "windows") // disable scroll optimization on Windows due to bugs in some terminals
+ s.scr = scr
+}
+
+// setColorProfile implements renderer.
+func (s *cursedRenderer) setColorProfile(p colorprofile.Profile) {
+ s.mu.Lock()
+ s.profile = p
+ s.scr.SetColorProfile(p)
+ s.mu.Unlock()
+}
+
+// resize implements renderer.
+func (s *cursedRenderer) resize(w, h int) {
+ s.mu.Lock()
+ // We need to mark the screen for clear to force a redraw. However, we
+ // only do so if we're using alt screen or the width has changed.
+ // That's because redrawing is expensive and we can avoid it if the
+ // width hasn't changed in inline mode. On the other hand, when using
+ // alt screen mode, we always want to redraw because some terminals
+ // would scroll the screen and our content would be lost.
+ s.scr.Erase()
+ s.width, s.height = w, h
+ s.scr.Resize(s.width, s.height)
+ s.mu.Unlock()
+}
+
+// clearScreen implements renderer.
+func (s *cursedRenderer) clearScreen() {
+ s.mu.Lock()
+ // Move the cursor to the top left corner of the screen and trigger a full
+ // screen redraw.
+ s.scr.MoveTo(0, 0)
+ s.scr.Erase()
+ s.mu.Unlock()
+}
+
+// enableAltScreen sets the alt screen mode.
+// Note that this writes to the buffer directly if write is true.
+func enableAltScreen(s *cursedRenderer, enable bool, write bool) {
+ if enable {
+ enterAltScreen(s, write)
+ } else {
+ exitAltScreen(s, write)
+ }
+}
+
+func enterAltScreen(s *cursedRenderer, write bool) {
+ s.scr.SaveCursor()
+ if write {
+ s.buf.WriteString(ansi.SetModeAltScreenSaveCursor)
+ }
+ s.scr.SetFullscreen(true)
+ s.scr.SetRelativeCursor(false)
+ s.scr.Erase()
+}
+
+func exitAltScreen(s *cursedRenderer, write bool) {
+ s.scr.Erase()
+ s.scr.SetRelativeCursor(true)
+ s.scr.SetFullscreen(false)
+ if write {
+ s.buf.WriteString(ansi.ResetModeAltScreenSaveCursor)
+ }
+ s.scr.RestoreCursor()
+}
+
+// enableTextCursor sets the text cursor mode.
+func enableTextCursor(s *cursedRenderer, enable bool) {
+ if enable {
+ _, _ = s.scr.WriteString(ansi.SetModeTextCursorEnable)
+ } else {
+ _, _ = s.scr.WriteString(ansi.ResetModeTextCursorEnable)
+ }
+}
+
+// setSyncdUpdates implements renderer.
+func (s *cursedRenderer) setSyncdUpdates(syncd bool) {
+ s.mu.Lock()
+ s.syncdUpdates = syncd
+ s.mu.Unlock()
+}
+
+// setWidthMethod implements renderer.
+func (s *cursedRenderer) setWidthMethod(method ansi.Method) {
+ s.mu.Lock()
+ if method == ansi.GraphemeWidth {
+ // Turn on Unicode mode (2027) for accurate grapheme width calculation.
+ // This is needed for proper rendering of wide characters and emojis.
+ _, _ = s.scr.WriteString(ansi.SetModeUnicodeCore)
+ } else if s.cellbuf.Method == ansi.GraphemeWidth {
+ // Turn off Unicode mode if we're switching away from grapheme width
+ // calculation to avoid issues with some terminals that might still be
+ // in Unicode mode and render characters incorrectly.
+ _, _ = s.scr.WriteString(ansi.ResetModeUnicodeCore)
+ }
+ s.cellbuf.Method = method
+ s.mu.Unlock()
+}
+
+// insertAbove implements renderer.
+func (s *cursedRenderer) insertAbove(str string) error {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ if len(str) == 0 {
+ return nil
+ }
+
+ var sb strings.Builder
+ w, h := s.cellbuf.Width(), s.cellbuf.Height()
+ _, y := s.scr.Position()
+
+ // We need to scroll the screen up by the number of lines in the queue.
+ sb.WriteByte('\r')
+ down := h - y - 1
+ if down > 0 {
+ sb.WriteString(ansi.CursorDown(down))
+ }
+
+ lines := strings.Split(str, "\n")
+ offset := len(lines)
+ for _, line := range lines {
+ lineWidth := ansi.StringWidth(line)
+ if w > 0 && lineWidth > w {
+ offset += (lineWidth / w)
+ }
+ }
+
+ // Scroll the screen up by the offset to make room for the new lines.
+ sb.WriteString(strings.Repeat("\n", offset))
+
+ // XXX: Now go to the top of the screen, insert new lines, and write
+ // the queued strings. It is important to use [Screen.moveCursor]
+ // instead of [Screen.move] because we don't want to perform any checks
+ // on the cursor position.
+ up := offset + h - 1
+ sb.WriteString(ansi.CursorUp(up))
+ sb.WriteString(ansi.InsertLine(offset))
+ for _, line := range lines {
+ sb.WriteString(line)
+ sb.WriteString(ansi.EraseLineRight)
+ sb.WriteString("\r\n")
+ }
+
+ s.scr.SetPosition(0, 0)
+
+ if s.logger != nil {
+ s.logger.Printf("insert above: %q", sb.String())
+ }
+
+ _, err := io.WriteString(s.w, sb.String())
+ if err != nil {
+ return fmt.Errorf("bubbletea: error writing insert above to the writer: %w", err)
+ }
+
+ return nil
+}
+
+// onMouse implements renderer.
+func (s *cursedRenderer) onMouse(m MouseMsg) Cmd {
+ if s.lastView != nil && s.lastView.OnMouse != nil {
+ return s.lastView.OnMouse(m)
+ }
+ return nil
+}
+
+func setProgressBar(s *cursedRenderer, pb *ProgressBar) {
+ if pb == nil {
+ _, _ = s.scr.WriteString(ansi.ResetProgressBar)
+ return
+ }
+
+ var seq string
+ switch pb.State {
+ case ProgressBarNone:
+ seq = ansi.ResetProgressBar
+ case ProgressBarDefault:
+ seq = ansi.SetProgressBar(pb.Value)
+ case ProgressBarError:
+ seq = ansi.SetErrorProgressBar(pb.Value)
+ case ProgressBarIndeterminate:
+ seq = ansi.SetIndeterminateProgressBar
+ case ProgressBarWarning:
+ seq = ansi.SetWarningProgressBar(pb.Value)
+ }
+ if seq != "" {
+ _, _ = s.scr.WriteString(seq)
+ }
+}
+
+func viewEquals(a, b *View) bool {
+ if a == nil || b == nil {
+ return false
+ }
+
+ if a.Content != b.Content ||
+ a.AltScreen != b.AltScreen ||
+ a.DisableBracketedPasteMode != b.DisableBracketedPasteMode ||
+ a.ReportFocus != b.ReportFocus ||
+ a.MouseMode != b.MouseMode ||
+ a.WindowTitle != b.WindowTitle ||
+ a.ForegroundColor != b.ForegroundColor ||
+ a.BackgroundColor != b.BackgroundColor ||
+ a.KeyboardEnhancements != b.KeyboardEnhancements {
+ return false
+ }
+
+ if (a.Cursor == nil) != (b.Cursor == nil) {
+ return false
+ }
+ if a.Cursor != nil && b.Cursor != nil {
+ if a.Cursor.X != b.Cursor.X ||
+ a.Cursor.Y != b.Cursor.Y ||
+ a.Cursor.Shape != b.Cursor.Shape ||
+ a.Cursor.Blink != b.Cursor.Blink ||
+ a.Cursor.Color != b.Cursor.Color {
+ return false
+ }
+ }
+
+ if (a.ProgressBar == nil) != (b.ProgressBar == nil) {
+ return false
+ }
+ if a.ProgressBar != nil && b.ProgressBar != nil {
+ if *a.ProgressBar != *b.ProgressBar {
+ return false
+ }
+ }
+
+ return true
+}
+
+func keyboardEnhancementsFlags(ke KeyboardEnhancements) int {
+ flags := 1 // always enable basic key disambiguation
+ if ke.ReportEventTypes {
+ flags |= ansi.KittyReportEventTypes
+ }
+ if ke.ReportAlternateKeys {
+ flags |= ansi.KittyReportAlternateKeys
+ }
+ if ke.ReportAllKeysAsEscapeCodes {
+ flags |= ansi.KittyReportAllKeysAsEscapeCodes
+ }
+ if ke.ReportAssociatedText {
+ flags |= ansi.KittyReportAssociatedKeys
+ }
+ return flags
+}
diff --git a/vendor/charm.land/bubbletea/v2/cursor.go b/vendor/charm.land/bubbletea/v2/cursor.go
new file mode 100644
index 000000000..3375a9652
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/cursor.go
@@ -0,0 +1,28 @@
+package tea
+
+// Position represents a position in the terminal.
+type Position struct{ X, Y int }
+
+// CursorPositionMsg is a message that represents the terminal cursor position.
+type CursorPositionMsg struct {
+ X, Y int
+}
+
+// CursorShape represents a terminal cursor shape.
+type CursorShape int
+
+// Cursor shapes.
+const (
+ CursorBlock CursorShape = iota
+ CursorUnderline
+ CursorBar
+)
+
+// requestCursorPosMsg is a message that requests the cursor position.
+type requestCursorPosMsg struct{}
+
+// RequestCursorPosition is a command that requests the cursor position.
+// The cursor position will be sent as a [CursorPositionMsg] message.
+func RequestCursorPosition() Msg {
+ return requestCursorPosMsg{}
+}
diff --git a/vendor/charm.land/bubbletea/v2/environ.go b/vendor/charm.land/bubbletea/v2/environ.go
new file mode 100644
index 000000000..8217b02f4
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/environ.go
@@ -0,0 +1,34 @@
+package tea
+
+import uv "github.com/charmbracelet/ultraviolet"
+
+// EnvMsg is a message that represents the environment variables of the
+// program. This is useful for getting the environment variables of programs
+// running in a remote session like SSH. In that case, using [os.Getenv] would
+// return the server's environment variables, not the client's.
+//
+// This message is sent to the program when it starts.
+//
+// Example:
+//
+// switch msg := msg.(type) {
+// case EnvMsg:
+// // What terminal type is being used?
+// term := msg.Getenv("TERM")
+// }
+type EnvMsg uv.Environ
+
+// Getenv returns the value of the environment variable named by the key. If
+// the variable is not present in the environment, the value returned will be
+// the empty string.
+func (msg EnvMsg) Getenv(key string) (v string) {
+ return uv.Environ(msg).Getenv(key)
+}
+
+// LookupEnv retrieves the value of the environment variable named by the key.
+// If the variable is present in the environment the value (which may be empty)
+// is returned and the boolean is true. Otherwise the returned value will be
+// empty and the boolean will be false.
+func (msg EnvMsg) LookupEnv(key string) (s string, v bool) {
+ return uv.Environ(msg).LookupEnv(key)
+}
diff --git a/vendor/charm.land/bubbletea/v2/exec.go b/vendor/charm.land/bubbletea/v2/exec.go
new file mode 100644
index 000000000..e8af5c42f
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/exec.go
@@ -0,0 +1,129 @@
+package tea
+
+import (
+ "io"
+ "os"
+ "os/exec"
+)
+
+// execMsg is used internally to run an ExecCommand sent with Exec.
+type execMsg struct {
+ cmd ExecCommand
+ fn ExecCallback
+}
+
+// Exec is used to perform arbitrary I/O in a blocking fashion, effectively
+// pausing the Program while execution is running and resuming it when
+// execution has completed.
+//
+// Most of the time you'll want to use ExecProcess, which runs an exec.Cmd.
+//
+// For non-interactive i/o you should use a Cmd (that is, a tea.Cmd).
+func Exec(c ExecCommand, fn ExecCallback) Cmd {
+ return func() Msg {
+ return execMsg{cmd: c, fn: fn}
+ }
+}
+
+// ExecProcess runs the given *exec.Cmd in a blocking fashion, effectively
+// pausing the Program while the command is running. After the *exec.Cmd exists
+// the Program resumes. It's useful for spawning other interactive applications
+// such as editors and shells from within a Program.
+//
+// To produce the command, pass an *exec.Cmd and a function which returns
+// a message containing the error which may have occurred when running the
+// ExecCommand.
+//
+// type VimFinishedMsg struct { err error }
+//
+// c := exec.Command("vim", "file.txt")
+//
+// cmd := ExecProcess(c, func(err error) Msg {
+// return VimFinishedMsg{err: err}
+// })
+//
+// Or, if you don't care about errors, you could simply:
+//
+// cmd := ExecProcess(exec.Command("vim", "file.txt"), nil)
+//
+// For non-interactive i/o you should use a Cmd (that is, a tea.Cmd).
+func ExecProcess(c *exec.Cmd, fn ExecCallback) Cmd {
+ return Exec(wrapExecCommand(c), fn)
+}
+
+// ExecCallback is used when executing an *exec.Command to return a message
+// with an error, which may or may not be nil.
+type ExecCallback func(error) Msg
+
+// ExecCommand can be implemented to execute things in a blocking fashion in
+// the current terminal.
+type ExecCommand interface {
+ Run() error
+ SetStdin(io.Reader)
+ SetStdout(io.Writer)
+ SetStderr(io.Writer)
+}
+
+// wrapExecCommand wraps an exec.Cmd so that it satisfies the ExecCommand
+// interface so it can be used with Exec.
+func wrapExecCommand(c *exec.Cmd) ExecCommand {
+ return &osExecCommand{Cmd: c}
+}
+
+// osExecCommand is a layer over an exec.Cmd that satisfies the ExecCommand
+// interface.
+type osExecCommand struct{ *exec.Cmd }
+
+// SetStdin sets stdin on underlying exec.Cmd to the given io.Reader.
+func (c *osExecCommand) SetStdin(r io.Reader) {
+ // If unset, have the command use the same input as the terminal.
+ if c.Stdin == nil {
+ c.Stdin = r
+ }
+}
+
+// SetStdout sets stdout on underlying exec.Cmd to the given io.Writer.
+func (c *osExecCommand) SetStdout(w io.Writer) {
+ // If unset, have the command use the same output as the terminal.
+ if c.Stdout == nil {
+ c.Stdout = w
+ }
+}
+
+// SetStderr sets stderr on the underlying exec.Cmd to the given io.Writer.
+func (c *osExecCommand) SetStderr(w io.Writer) {
+ // If unset, use stderr for the command's stderr
+ if c.Stderr == nil {
+ c.Stderr = w
+ }
+}
+
+// exec runs an ExecCommand and delivers the results to the program as a Msg.
+func (p *Program) exec(c ExecCommand, fn ExecCallback) {
+ if err := p.releaseTerminal(false); err != nil {
+ // If we can't release input, abort.
+ if fn != nil {
+ go p.Send(fn(err))
+ }
+ return
+ }
+
+ c.SetStdin(p.input)
+ c.SetStdout(p.output)
+ c.SetStderr(os.Stderr)
+
+ // Execute system command.
+ if err := c.Run(); err != nil {
+ _ = p.RestoreTerminal() // also try to restore the terminal.
+ if fn != nil {
+ go p.Send(fn(err))
+ }
+ return
+ }
+
+ // Have the program re-capture input.
+ err := p.RestoreTerminal()
+ if fn != nil {
+ go p.Send(fn(err))
+ }
+}
diff --git a/vendor/charm.land/bubbletea/v2/focus.go b/vendor/charm.land/bubbletea/v2/focus.go
new file mode 100644
index 000000000..4d34bea6f
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/focus.go
@@ -0,0 +1,9 @@
+package tea
+
+// FocusMsg represents a terminal focus message.
+// This occurs when the terminal gains focus.
+type FocusMsg struct{}
+
+// BlurMsg represents a terminal blur message.
+// This occurs when the terminal loses focus.
+type BlurMsg struct{}
diff --git a/vendor/charm.land/bubbletea/v2/input.go b/vendor/charm.land/bubbletea/v2/input.go
new file mode 100644
index 000000000..db274fb0b
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/input.go
@@ -0,0 +1,54 @@
+package tea
+
+import (
+ uv "github.com/charmbracelet/ultraviolet"
+)
+
+// translateInputEvent translates an input event into a Bubble Tea Msg.
+func (p *Program) translateInputEvent(e uv.Event) Msg {
+ switch e := e.(type) {
+ case uv.ClipboardEvent:
+ return ClipboardMsg(e)
+ case uv.ForegroundColorEvent:
+ return ForegroundColorMsg(e)
+ case uv.BackgroundColorEvent:
+ return BackgroundColorMsg(e)
+ case uv.CursorColorEvent:
+ return CursorColorMsg(e)
+ case uv.CursorPositionEvent:
+ return CursorPositionMsg(e)
+ case uv.FocusEvent:
+ return FocusMsg(e)
+ case uv.BlurEvent:
+ return BlurMsg(e)
+ case uv.KeyPressEvent:
+ return KeyPressMsg(e)
+ case uv.KeyReleaseEvent:
+ return KeyReleaseMsg(e)
+ case uv.MouseClickEvent:
+ return MouseClickMsg(e)
+ case uv.MouseMotionEvent:
+ return MouseMotionMsg(e)
+ case uv.MouseReleaseEvent:
+ return MouseReleaseMsg(e)
+ case uv.MouseWheelEvent:
+ return MouseWheelMsg(e)
+ case uv.PasteEvent:
+ return PasteMsg(e)
+ case uv.PasteStartEvent:
+ return PasteStartMsg(e)
+ case uv.PasteEndEvent:
+ return PasteEndMsg(e)
+ case uv.WindowSizeEvent:
+ return WindowSizeMsg(e)
+ case uv.CapabilityEvent:
+ return CapabilityMsg(e)
+ case uv.TerminalVersionEvent:
+ return TerminalVersionMsg(e)
+ case uv.KeyboardEnhancementsEvent:
+ return KeyboardEnhancementsMsg(e)
+ case uv.ModeReportEvent:
+ return ModeReportMsg(e)
+ }
+ return e
+}
diff --git a/vendor/charm.land/bubbletea/v2/key.go b/vendor/charm.land/bubbletea/v2/key.go
new file mode 100644
index 000000000..b16e53c2f
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/key.go
@@ -0,0 +1,371 @@
+package tea
+
+import (
+ "fmt"
+
+ uv "github.com/charmbracelet/ultraviolet"
+)
+
+const (
+ // KeyExtended is a special key code used to signify that a key event
+ // contains multiple runes.
+ KeyExtended = uv.KeyExtended
+)
+
+// Special key symbols.
+const (
+
+ // Special keys.
+
+ KeyUp = uv.KeyUp
+ KeyDown = uv.KeyDown
+ KeyRight = uv.KeyRight
+ KeyLeft = uv.KeyLeft
+ KeyBegin = uv.KeyBegin
+ KeyFind = uv.KeyFind
+ KeyInsert = uv.KeyInsert
+ KeyDelete = uv.KeyDelete
+ KeySelect = uv.KeySelect
+ KeyPgUp = uv.KeyPgUp
+ KeyPgDown = uv.KeyPgDown
+ KeyHome = uv.KeyHome
+ KeyEnd = uv.KeyEnd
+
+ // Keypad keys.
+
+ KeyKpEnter = uv.KeyKpEnter
+ KeyKpEqual = uv.KeyKpEqual
+ KeyKpMultiply = uv.KeyKpMultiply
+ KeyKpPlus = uv.KeyKpPlus
+ KeyKpComma = uv.KeyKpComma
+ KeyKpMinus = uv.KeyKpMinus
+ KeyKpDecimal = uv.KeyKpDecimal
+ KeyKpDivide = uv.KeyKpDivide
+ KeyKp0 = uv.KeyKp0
+ KeyKp1 = uv.KeyKp1
+ KeyKp2 = uv.KeyKp2
+ KeyKp3 = uv.KeyKp3
+ KeyKp4 = uv.KeyKp4
+ KeyKp5 = uv.KeyKp5
+ KeyKp6 = uv.KeyKp6
+ KeyKp7 = uv.KeyKp7
+ KeyKp8 = uv.KeyKp8
+ KeyKp9 = uv.KeyKp9
+
+ // The following are keys defined in the Kitty keyboard protocol.
+ // XXX: Investigate the names of these keys.
+ KeyKpSep = uv.KeyKpSep
+ KeyKpUp = uv.KeyKpUp
+ KeyKpDown = uv.KeyKpDown
+ KeyKpLeft = uv.KeyKpLeft
+ KeyKpRight = uv.KeyKpRight
+ KeyKpPgUp = uv.KeyKpPgUp
+ KeyKpPgDown = uv.KeyKpPgDown
+ KeyKpHome = uv.KeyKpHome
+ KeyKpEnd = uv.KeyKpEnd
+ KeyKpInsert = uv.KeyKpInsert
+ KeyKpDelete = uv.KeyKpDelete
+ KeyKpBegin = uv.KeyKpBegin
+
+ // Function keys.
+
+ KeyF1 = uv.KeyF1
+ KeyF2 = uv.KeyF2
+ KeyF3 = uv.KeyF3
+ KeyF4 = uv.KeyF4
+ KeyF5 = uv.KeyF5
+ KeyF6 = uv.KeyF6
+ KeyF7 = uv.KeyF7
+ KeyF8 = uv.KeyF8
+ KeyF9 = uv.KeyF9
+ KeyF10 = uv.KeyF10
+ KeyF11 = uv.KeyF11
+ KeyF12 = uv.KeyF12
+ KeyF13 = uv.KeyF13
+ KeyF14 = uv.KeyF14
+ KeyF15 = uv.KeyF15
+ KeyF16 = uv.KeyF16
+ KeyF17 = uv.KeyF17
+ KeyF18 = uv.KeyF18
+ KeyF19 = uv.KeyF19
+ KeyF20 = uv.KeyF20
+ KeyF21 = uv.KeyF21
+ KeyF22 = uv.KeyF22
+ KeyF23 = uv.KeyF23
+ KeyF24 = uv.KeyF24
+ KeyF25 = uv.KeyF25
+ KeyF26 = uv.KeyF26
+ KeyF27 = uv.KeyF27
+ KeyF28 = uv.KeyF28
+ KeyF29 = uv.KeyF29
+ KeyF30 = uv.KeyF30
+ KeyF31 = uv.KeyF31
+ KeyF32 = uv.KeyF32
+ KeyF33 = uv.KeyF33
+ KeyF34 = uv.KeyF34
+ KeyF35 = uv.KeyF35
+ KeyF36 = uv.KeyF36
+ KeyF37 = uv.KeyF37
+ KeyF38 = uv.KeyF38
+ KeyF39 = uv.KeyF39
+ KeyF40 = uv.KeyF40
+ KeyF41 = uv.KeyF41
+ KeyF42 = uv.KeyF42
+ KeyF43 = uv.KeyF43
+ KeyF44 = uv.KeyF44
+ KeyF45 = uv.KeyF45
+ KeyF46 = uv.KeyF46
+ KeyF47 = uv.KeyF47
+ KeyF48 = uv.KeyF48
+ KeyF49 = uv.KeyF49
+ KeyF50 = uv.KeyF50
+ KeyF51 = uv.KeyF51
+ KeyF52 = uv.KeyF52
+ KeyF53 = uv.KeyF53
+ KeyF54 = uv.KeyF54
+ KeyF55 = uv.KeyF55
+ KeyF56 = uv.KeyF56
+ KeyF57 = uv.KeyF57
+ KeyF58 = uv.KeyF58
+ KeyF59 = uv.KeyF59
+ KeyF60 = uv.KeyF60
+ KeyF61 = uv.KeyF61
+ KeyF62 = uv.KeyF62
+ KeyF63 = uv.KeyF63
+
+ // The following are keys defined in the Kitty keyboard protocol.
+ // XXX: Investigate the names of these keys.
+
+ KeyCapsLock = uv.KeyCapsLock
+ KeyScrollLock = uv.KeyScrollLock
+ KeyNumLock = uv.KeyNumLock
+ KeyPrintScreen = uv.KeyPrintScreen
+ KeyPause = uv.KeyPause
+ KeyMenu = uv.KeyMenu
+
+ KeyMediaPlay = uv.KeyMediaPlay
+ KeyMediaPause = uv.KeyMediaPause
+ KeyMediaPlayPause = uv.KeyMediaPlayPause
+ KeyMediaReverse = uv.KeyMediaReverse
+ KeyMediaStop = uv.KeyMediaStop
+ KeyMediaFastForward = uv.KeyMediaFastForward
+ KeyMediaRewind = uv.KeyMediaRewind
+ KeyMediaNext = uv.KeyMediaNext
+ KeyMediaPrev = uv.KeyMediaPrev
+ KeyMediaRecord
+
+ KeyLowerVol = uv.KeyLowerVol
+ KeyRaiseVol = uv.KeyRaiseVol
+ KeyMute = uv.KeyMute
+
+ KeyLeftShift = uv.KeyLeftShift
+ KeyLeftAlt = uv.KeyLeftAlt
+ KeyLeftCtrl = uv.KeyLeftCtrl
+ KeyLeftSuper = uv.KeyLeftSuper
+ KeyLeftHyper = uv.KeyLeftHyper
+ KeyLeftMeta = uv.KeyLeftMeta
+ KeyRightShift = uv.KeyRightShift
+ KeyRightAlt = uv.KeyRightAlt
+ KeyRightCtrl = uv.KeyRightCtrl
+ KeyRightSuper = uv.KeyRightSuper
+ KeyRightHyper = uv.KeyRightHyper
+ KeyRightMeta = uv.KeyRightMeta
+ KeyIsoLevel3Shift = uv.KeyIsoLevel3Shift
+ KeyIsoLevel5Shift = uv.KeyIsoLevel5Shift
+
+ // Special names in C0.
+
+ KeyBackspace = uv.KeyBackspace
+ KeyTab = uv.KeyTab
+ KeyEnter = uv.KeyEnter
+ KeyReturn = uv.KeyReturn
+ KeyEscape = uv.KeyEscape
+ KeyEsc = uv.KeyEsc
+
+ // Special names in G0.
+
+ KeySpace = uv.KeySpace
+)
+
+// KeyPressMsg represents a key press message.
+type KeyPressMsg Key
+
+// String implements [fmt.Stringer] and is quite useful for matching key
+// events. For details, on what this returns see [Key.String].
+func (k KeyPressMsg) String() string {
+ return Key(k).String()
+}
+
+// Keystroke returns the keystroke representation of the [Key]. While less type
+// safe than looking at the individual fields, it will usually be more
+// convenient and readable to use this method when matching against keys.
+//
+// Note that modifier keys are always printed in the following order:
+// - ctrl
+// - alt
+// - shift
+// - meta
+// - hyper
+// - super
+//
+// For example, you'll always see "ctrl+shift+alt+a" and never
+// "shift+ctrl+alt+a".
+func (k KeyPressMsg) Keystroke() string {
+ return uv.Key(k).Keystroke()
+}
+
+// Key returns the underlying key event. This is a syntactic sugar for casting
+// the key event to a [Key].
+func (k KeyPressMsg) Key() Key {
+ return Key(k)
+}
+
+// KeyReleaseMsg represents a key release message.
+type KeyReleaseMsg Key
+
+// String implements [fmt.Stringer] and is quite useful for matching key
+// events. For details, on what this returns see [Key.String].
+func (k KeyReleaseMsg) String() string {
+ return Key(k).String()
+}
+
+// Keystroke returns the keystroke representation of the [Key]. While less type
+// safe than looking at the individual fields, it will usually be more
+// convenient and readable to use this method when matching against keys.
+//
+// Note that modifier keys are always printed in the following order:
+// - ctrl
+// - alt
+// - shift
+// - meta
+// - hyper
+// - super
+//
+// For example, you'll always see "ctrl+shift+alt+a" and never
+// "shift+ctrl+alt+a".
+func (k KeyReleaseMsg) Keystroke() string {
+ return uv.Key(k).Keystroke()
+}
+
+// Key returns the underlying key event. This is a convenience method and
+// syntactic sugar to satisfy the [KeyMsg] interface, and cast the key event to
+// [Key].
+func (k KeyReleaseMsg) Key() Key {
+ return Key(k)
+}
+
+// KeyMsg represents a key event. This can be either a key press or a key
+// release event.
+type KeyMsg interface {
+ fmt.Stringer
+
+ // Key returns the underlying key event.
+ Key() Key
+}
+
+// Key represents a Key press or release event. It contains information about
+// the Key pressed, like the runes, the type of Key, and the modifiers pressed.
+// There are a couple general patterns you could use to check for key presses
+// or releases:
+//
+// // Switch on the string representation of the key (shorter)
+// switch msg := msg.(type) {
+// case KeyPressMsg:
+// switch msg.String() {
+// case "enter":
+// fmt.Println("you pressed enter!")
+// case "a":
+// fmt.Println("you pressed a!")
+// }
+// }
+//
+// // Switch on the key type (more foolproof)
+// switch msg := msg.(type) {
+// case KeyMsg:
+// // catch both KeyPressMsg and KeyReleaseMsg
+// switch key := msg.Key(); key.Code {
+// case KeyEnter:
+// fmt.Println("you pressed enter!")
+// default:
+// switch key.Text {
+// case "a":
+// fmt.Println("you pressed a!")
+// }
+// }
+// }
+//
+// Note that [Key.Text] will be empty for special keys like [KeyEnter],
+// [KeyTab], and for keys that don't represent printable characters like key
+// combos with modifier keys. In other words, [Key.Text] is populated only for
+// keys that represent printable characters shifted or unshifted (like 'a',
+// 'A', '1', '!', etc.).
+type Key struct {
+ // Text contains the actual characters received. This usually the same as
+ // [Key.Code]. When [Key.Text] is non-empty, it indicates that the key
+ // pressed represents printable character(s).
+ Text string
+
+ // Mod represents modifier keys, like [ModCtrl], [ModAlt], and so on.
+ Mod KeyMod
+
+ // Code represents the key pressed. This is usually a special key like
+ // [KeyTab], [KeyEnter], [KeyF1], or a printable character like 'a'.
+ Code rune
+
+ // ShiftedCode is the actual, shifted key pressed by the user. For example,
+ // if the user presses shift+a, or caps lock is on, [Key.ShiftedCode] will
+ // be 'A' and [Key.Code] will be 'a'.
+ //
+ // In the case of non-latin keyboards, like Arabic, [Key.ShiftedCode] is the
+ // unshifted key on the keyboard.
+ //
+ // This is only available with the Kitty Keyboard Protocol or the Windows
+ // Console API.
+ ShiftedCode rune
+
+ // BaseCode is the key pressed according to the standard PC-101 key layout.
+ // On international keyboards, this is the key that would be pressed if the
+ // keyboard was set to US PC-101 layout.
+ //
+ // For example, if the user presses 'q' on a French AZERTY keyboard,
+ // [Key.BaseCode] will be 'q'.
+ //
+ // This is only available with the Kitty Keyboard Protocol or the Windows
+ // Console API.
+ BaseCode rune
+
+ // IsRepeat indicates whether the key is being held down and sending events
+ // repeatedly.
+ //
+ // This is only available with the Kitty Keyboard Protocol or the Windows
+ // Console API.
+ IsRepeat bool
+}
+
+// String implements [fmt.Stringer] and is quite useful for matching key
+// events. It will return the textual representation of the [Key] if there is
+// one, otherwise, it will fallback to [Key.Keystroke].
+//
+// For example, you'll always get "?" and instead of "shift+/" on a US ANSI
+// keyboard.
+func (k Key) String() string {
+ return uv.Key(k).String()
+}
+
+// Keystroke returns the keystroke representation of the [Key]. While less type
+// safe than looking at the individual fields, it will usually be more
+// convenient and readable to use this method when matching against keys.
+//
+// Note that modifier keys are always printed in the following order:
+// - ctrl
+// - alt
+// - shift
+// - meta
+// - hyper
+// - super
+//
+// For example, you'll always see "ctrl+shift+alt+a" and never
+// "shift+ctrl+alt+a".
+func (k Key) Keystroke() string {
+ return uv.Key(k).Keystroke()
+}
diff --git a/vendor/charm.land/bubbletea/v2/keyboard.go b/vendor/charm.land/bubbletea/v2/keyboard.go
new file mode 100644
index 000000000..33747a456
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/keyboard.go
@@ -0,0 +1,59 @@
+package tea
+
+import (
+ "github.com/charmbracelet/x/ansi"
+)
+
+// KeyboardEnhancementsMsg is a message that gets sent when the terminal
+// supports keyboard enhancements.
+type KeyboardEnhancementsMsg struct {
+ // Flags is a bitmask of enabled keyboard enhancement features. A non-zero
+ // value indicates that at least we have key disambiguation support.
+ //
+ // See [ansi.KittyReportEventTypes] and other constants for details.
+ //
+ // Example:
+ //
+ // ```go
+ // // The hard way
+ // if msg.Flags&ansi.KittyReportEventTypes != 0 {
+ // // Terminal supports reporting different key event types
+ // }
+ //
+ // // The easy way
+ // if msg.SupportsEventTypes() {
+ // // Terminal supports reporting different key event types
+ // }
+ // ```
+ Flags int
+}
+
+// SupportsKeyDisambiguation returns whether the terminal supports key
+// disambiguation (e.g., distinguishing between different modifier keys).
+func (k KeyboardEnhancementsMsg) SupportsKeyDisambiguation() bool {
+ return k.Flags > 0
+}
+
+// SupportsEventTypes returns whether the terminal supports reporting
+// different types of key events (press, release, and repeat).
+func (k KeyboardEnhancementsMsg) SupportsEventTypes() bool {
+ return k.Flags&ansi.KittyReportEventTypes != 0
+}
+
+// SupportsAlternateKeys returns whether the terminal supports reporting
+// alternate key codes.
+func (k KeyboardEnhancementsMsg) SupportsAlternateKeys() bool {
+ return k.Flags&ansi.KittyReportAlternateKeys != 0
+}
+
+// SupportsAllKeysAsEscapeCodes returns whether the terminal supports reporting
+// all keys as escape codes.
+func (k KeyboardEnhancementsMsg) SupportsAllKeysAsEscapeCodes() bool {
+ return k.Flags&ansi.KittyReportAllKeysAsEscapeCodes != 0
+}
+
+// SupportsAssociatedText returns whether the terminal supports reporting
+// associated text with key events.
+func (k KeyboardEnhancementsMsg) SupportsAssociatedText() bool {
+ return k.Flags&ansi.KittyReportAssociatedKeys != 0
+}
diff --git a/vendor/charm.land/bubbletea/v2/logging.go b/vendor/charm.land/bubbletea/v2/logging.go
new file mode 100644
index 000000000..349758cbc
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/logging.go
@@ -0,0 +1,53 @@
+package tea
+
+import (
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "unicode"
+)
+
+// LogToFile sets up default logging to log to a file. This is helpful as we
+// can't print to the terminal since our TUI is occupying it. If the file
+// doesn't exist it will be created.
+//
+// Don't forget to close the file when you're done with it.
+//
+// f, err := LogToFile("debug.log", "debug")
+// if err != nil {
+// fmt.Println("fatal:", err)
+// os.Exit(1)
+// }
+// defer f.Close()
+func LogToFile(path string, prefix string) (*os.File, error) {
+ return LogToFileWith(path, prefix, log.Default())
+}
+
+// LogOptionsSetter is an interface implemented by stdlib's log and charm's log
+// libraries.
+type LogOptionsSetter interface {
+ SetOutput(io.Writer)
+ SetPrefix(string)
+}
+
+// LogToFileWith does allows to call LogToFile with a custom LogOptionsSetter.
+func LogToFileWith(path string, prefix string, log LogOptionsSetter) (*os.File, error) {
+ f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0o600) //nolint:mnd
+ if err != nil {
+ return nil, fmt.Errorf("error opening file for logging: %w", err)
+ }
+ log.SetOutput(f)
+
+ // Add a space after the prefix if a prefix is being specified and it
+ // doesn't already have a trailing space.
+ if len(prefix) > 0 {
+ finalChar := prefix[len(prefix)-1]
+ if !unicode.IsSpace(rune(finalChar)) {
+ prefix += " "
+ }
+ }
+ log.SetPrefix(prefix)
+
+ return f, nil
+}
diff --git a/vendor/charm.land/bubbletea/v2/mod.go b/vendor/charm.land/bubbletea/v2/mod.go
new file mode 100644
index 000000000..f85a4c32c
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/mod.go
@@ -0,0 +1,27 @@
+package tea
+
+import uv "github.com/charmbracelet/ultraviolet"
+
+// KeyMod represents modifier keys.
+type KeyMod = uv.KeyMod
+
+// Modifier keys.
+const (
+ ModShift = uv.ModShift
+ ModAlt = uv.ModAlt
+ ModCtrl = uv.ModCtrl
+ ModMeta = uv.ModMeta
+
+ // These modifiers are used with the Kitty protocol.
+ // XXX: Meta and Super are swapped in the Kitty protocol,
+ // this is to preserve compatibility with XTerm modifiers.
+
+ ModHyper = uv.ModHyper
+ ModSuper = uv.ModSuper // Windows/Command keys
+
+ // These are key lock states.
+
+ ModCapsLock = uv.ModCapsLock
+ ModNumLock = uv.ModNumLock
+ ModScrollLock = uv.ModScrollLock // Defined in Windows API only
+)
diff --git a/vendor/charm.land/bubbletea/v2/mouse.go b/vendor/charm.land/bubbletea/v2/mouse.go
new file mode 100644
index 000000000..05b83128b
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/mouse.go
@@ -0,0 +1,144 @@
+package tea
+
+import (
+ "fmt"
+
+ uv "github.com/charmbracelet/ultraviolet"
+)
+
+// MouseButton represents the button that was pressed during a mouse message.
+type MouseButton = uv.MouseButton
+
+// Mouse event buttons
+//
+// This is based on X11 mouse button codes.
+//
+// 1 = left button
+// 2 = middle button (pressing the scroll wheel)
+// 3 = right button
+// 4 = turn scroll wheel up
+// 5 = turn scroll wheel down
+// 6 = push scroll wheel left
+// 7 = push scroll wheel right
+// 8 = 4th button (aka browser backward button)
+// 9 = 5th button (aka browser forward button)
+// 10
+// 11
+//
+// Other buttons are not supported.
+const (
+ MouseNone = uv.MouseNone
+ MouseLeft = uv.MouseLeft
+ MouseMiddle = uv.MouseMiddle
+ MouseRight = uv.MouseRight
+ MouseWheelUp = uv.MouseWheelUp
+ MouseWheelDown = uv.MouseWheelDown
+ MouseWheelLeft = uv.MouseWheelLeft
+ MouseWheelRight = uv.MouseWheelRight
+ MouseBackward = uv.MouseBackward
+ MouseForward = uv.MouseForward
+ MouseButton10 = uv.MouseButton10
+ MouseButton11
+)
+
+// MouseMsg represents a mouse message. This is a generic mouse message that
+// can represent any kind of mouse event.
+type MouseMsg interface {
+ fmt.Stringer
+
+ // Mouse returns the underlying mouse event.
+ Mouse() Mouse
+}
+
+// Mouse represents a Mouse message. Use [MouseMsg] to represent all mouse
+// messages.
+//
+// The X and Y coordinates are zero-based, with (0,0) being the upper left
+// corner of the terminal.
+//
+// // Catch all mouse events
+// switch msg := msg.(type) {
+// case MouseMsg:
+// m := msg.Mouse()
+// fmt.Println("Mouse event:", m.X, m.Y, m)
+// }
+//
+// // Only catch mouse click events
+// switch msg := msg.(type) {
+// case MouseClickMsg:
+// fmt.Println("Mouse click event:", msg.X, msg.Y, msg)
+// }
+type Mouse struct {
+ X, Y int
+ Button MouseButton
+ Mod KeyMod
+}
+
+// String returns a string representation of the mouse message.
+func (m Mouse) String() (s string) {
+ return uv.Mouse(m).String()
+}
+
+// MouseClickMsg represents a mouse button click message.
+type MouseClickMsg Mouse
+
+// String returns a string representation of the mouse click message.
+func (e MouseClickMsg) String() string {
+ return Mouse(e).String()
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseMsg] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseClickMsg) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// MouseReleaseMsg represents a mouse button release message.
+type MouseReleaseMsg Mouse
+
+// String returns a string representation of the mouse release message.
+func (e MouseReleaseMsg) String() string {
+ return Mouse(e).String()
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseMsg] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseReleaseMsg) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// MouseWheelMsg represents a mouse wheel message event.
+type MouseWheelMsg Mouse
+
+// String returns a string representation of the mouse wheel message.
+func (e MouseWheelMsg) String() string {
+ return Mouse(e).String()
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseMsg] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseWheelMsg) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// MouseMotionMsg represents a mouse motion message.
+type MouseMotionMsg Mouse
+
+// String returns a string representation of the mouse motion message.
+func (e MouseMotionMsg) String() string {
+ m := Mouse(e)
+ if m.Button != 0 {
+ return m.String() + "+motion"
+ }
+ return m.String() + "motion"
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseMsg] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseMotionMsg) Mouse() Mouse {
+ return Mouse(e)
+}
diff --git a/vendor/charm.land/bubbletea/v2/nil_renderer.go b/vendor/charm.land/bubbletea/v2/nil_renderer.go
new file mode 100644
index 000000000..1edafea7e
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/nil_renderer.go
@@ -0,0 +1,53 @@
+package tea
+
+import (
+ "github.com/charmbracelet/colorprofile"
+ "github.com/charmbracelet/x/ansi"
+)
+
+// nilRenderer is a no-op renderer. It implements the Renderer interface but
+// doesn't render anything to the terminal.
+type nilRenderer struct{}
+
+var _ renderer = nilRenderer{}
+
+// start implements renderer.
+func (n nilRenderer) start() {}
+
+// clearScreen implements renderer.
+func (n nilRenderer) clearScreen() {}
+
+// insertAbove implements renderer.
+func (n nilRenderer) insertAbove(string) error { return nil }
+
+// resize implements renderer.
+func (n nilRenderer) resize(int, int) {}
+
+// setColorProfile implements renderer.
+func (n nilRenderer) setColorProfile(colorprofile.Profile) {}
+
+// flush implements the Renderer interface.
+func (nilRenderer) flush(bool) error { return nil }
+
+// close implements the Renderer interface.
+func (nilRenderer) close() error { return nil }
+
+// render implements the Renderer interface.
+func (nilRenderer) render(View) {}
+
+// reset implements the Renderer interface.
+func (nilRenderer) reset() {}
+
+// writeString implements the Renderer interface.
+func (nilRenderer) writeString(string) (int, error) { return 0, nil }
+
+// setSyncdUpdates implements the Renderer interface.
+func (n nilRenderer) setSyncdUpdates(bool) {}
+
+// setWidthMethod implements the Renderer interface.
+func (n nilRenderer) setWidthMethod(ansi.Method) {}
+
+// onMouse implements the Renderer interface.
+func (n nilRenderer) onMouse(MouseMsg) Cmd {
+ return nil
+}
diff --git a/vendor/charm.land/bubbletea/v2/options.go b/vendor/charm.land/bubbletea/v2/options.go
new file mode 100644
index 000000000..dfd8cda4f
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/options.go
@@ -0,0 +1,168 @@
+package tea
+
+import (
+ "context"
+ "io"
+ "sync/atomic"
+
+ "github.com/charmbracelet/colorprofile"
+)
+
+// ProgramOption is used to set options when initializing a Program. Program can
+// accept a variable number of options.
+//
+// Example usage:
+//
+// p := NewProgram(model, WithInput(someInput), WithOutput(someOutput))
+type ProgramOption func(*Program)
+
+// WithContext lets you specify a context in which to run the Program. This is
+// useful if you want to cancel the execution from outside. When a Program gets
+// cancelled it will exit with an error ErrProgramKilled.
+func WithContext(ctx context.Context) ProgramOption {
+ return func(p *Program) {
+ p.externalCtx = ctx
+ }
+}
+
+// WithOutput sets the output which, by default, is stdout. In most cases you
+// won't need to use this.
+func WithOutput(output io.Writer) ProgramOption {
+ return func(p *Program) {
+ p.output = output
+ }
+}
+
+// WithInput sets the input which, by default, is stdin. In most cases you
+// won't need to use this. To disable input entirely pass nil.
+//
+// p := NewProgram(model, WithInput(nil))
+func WithInput(input io.Reader) ProgramOption {
+ return func(p *Program) {
+ p.input = input
+ p.disableInput = input == nil
+ }
+}
+
+// WithEnvironment sets the environment variables that the program will use.
+// This useful when the program is running in a remote session (e.g. SSH) and
+// you want to pass the environment variables from the remote session to the
+// program.
+//
+// Example:
+//
+// var sess ssh.Session // ssh.Session is a type from the github.com/charmbracelet/ssh package
+// pty, _, _ := sess.Pty()
+// environ := append(sess.Environ(), "TERM="+pty.Term)
+// p := tea.NewProgram(model, tea.WithEnvironment(environ)
+func WithEnvironment(env []string) ProgramOption {
+ return func(p *Program) {
+ p.environ = env
+ }
+}
+
+// WithoutSignalHandler disables the signal handler that Bubble Tea sets up for
+// Programs. This is useful if you want to handle signals yourself.
+func WithoutSignalHandler() ProgramOption {
+ return func(p *Program) {
+ p.disableSignalHandler = true
+ }
+}
+
+// WithoutCatchPanics disables the panic catching that Bubble Tea does by
+// default. If panic catching is disabled the terminal will be in a fairly
+// unusable state after a panic because Bubble Tea will not perform its usual
+// cleanup on exit.
+func WithoutCatchPanics() ProgramOption {
+ return func(p *Program) {
+ p.disableCatchPanics = true
+ }
+}
+
+// WithoutSignals will ignore OS signals.
+// This is mainly useful for testing.
+func WithoutSignals() ProgramOption {
+ return func(p *Program) {
+ atomic.StoreUint32(&p.ignoreSignals, 1)
+ }
+}
+
+// WithoutRenderer disables the renderer. When this is set output and log
+// statements will be plainly sent to stdout (or another output if one is set)
+// without any rendering and redrawing logic. In other words, printing and
+// logging will behave the same way it would in a non-TUI commandline tool.
+// This can be useful if you want to use the Bubble Tea framework for a non-TUI
+// application, or to provide an additional non-TUI mode to your Bubble Tea
+// programs. For example, your program could behave like a daemon if output is
+// not a TTY.
+func WithoutRenderer() ProgramOption {
+ return func(p *Program) {
+ p.disableRenderer = true
+ }
+}
+
+// WithFilter supplies an event filter that will be invoked before Bubble Tea
+// processes a tea.Msg. The event filter can return any tea.Msg which will then
+// get handled by Bubble Tea instead of the original event. If the event filter
+// returns nil, the event will be ignored and Bubble Tea will not process it.
+//
+// As an example, this could be used to prevent a program from shutting down if
+// there are unsaved changes.
+//
+// Example:
+//
+// func filter(m tea.Model, msg tea.Msg) tea.Msg {
+// if _, ok := msg.(tea.QuitMsg); !ok {
+// return msg
+// }
+//
+// model := m.(myModel)
+// if model.hasChanges {
+// return nil
+// }
+//
+// return msg
+// }
+//
+// p := tea.NewProgram(Model{}, tea.WithFilter(filter));
+//
+// if _,err := p.Run(); err != nil {
+// fmt.Println("Error running program:", err)
+// os.Exit(1)
+// }
+func WithFilter(filter func(Model, Msg) Msg) ProgramOption {
+ return func(p *Program) {
+ p.filter = filter
+ }
+}
+
+// WithFPS sets a custom maximum FPS at which the renderer should run. If
+// less than 1, the default value of 60 will be used. If over 120, the FPS
+// will be capped at 120.
+func WithFPS(fps int) ProgramOption {
+ return func(p *Program) {
+ p.fps = fps
+ }
+}
+
+// WithColorProfile sets the color profile that the program will use. This is
+// useful when you want to force a specific color profile. By default, Bubble
+// Tea will try to detect the terminal's color profile from environment
+// variables and terminfo capabilities. Use [tea.WithEnvironment] to set custom
+// environment variables.
+func WithColorProfile(profile colorprofile.Profile) ProgramOption {
+ return func(p *Program) {
+ p.profile = &profile
+ }
+}
+
+// WithWindowSize sets the initial size of the terminal window. This is useful
+// when you need to set the initial size of the terminal window, for example
+// during testing or when you want to run your program in a non-interactive
+// environment.
+func WithWindowSize(width, height int) ProgramOption {
+ return func(p *Program) {
+ p.width = width
+ p.height = height
+ }
+}
diff --git a/vendor/charm.land/bubbletea/v2/paste.go b/vendor/charm.land/bubbletea/v2/paste.go
new file mode 100644
index 000000000..6a3f54c1f
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/paste.go
@@ -0,0 +1,20 @@
+package tea
+
+// PasteMsg is an message that is emitted when a terminal receives pasted text
+// using bracketed-paste.
+type PasteMsg struct {
+ Content string
+}
+
+// String returns the pasted content as a string.
+func (p PasteMsg) String() string {
+ return p.Content
+}
+
+// PasteStartMsg is an message that is emitted when the terminal starts the
+// bracketed-paste text.
+type PasteStartMsg struct{}
+
+// PasteEndMsg is an message that is emitted when the terminal ends the
+// bracketed-paste text.
+type PasteEndMsg struct{}
diff --git a/vendor/charm.land/bubbletea/v2/profile.go b/vendor/charm.land/bubbletea/v2/profile.go
new file mode 100644
index 000000000..f67186636
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/profile.go
@@ -0,0 +1,15 @@
+package tea
+
+import "github.com/charmbracelet/colorprofile"
+
+// ColorProfileMsg is a message that describes the terminal's color profile.
+// This message is send to the program's update function when the program is
+// started.
+//
+// To upgrade the terminal color profile, use the `tea.RequestCapability`
+// command to request the `RGB` and `Tc` terminfo capabilities. Bubble Tea will
+// then cache the terminal's color profile and send a `ColorProfileMsg` to the
+// program's update function.
+type ColorProfileMsg struct {
+ colorprofile.Profile
+}
diff --git a/vendor/charm.land/bubbletea/v2/raw.go b/vendor/charm.land/bubbletea/v2/raw.go
new file mode 100644
index 000000000..fb6ae44dd
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/raw.go
@@ -0,0 +1,37 @@
+package tea
+
+// RawMsg is a message that contains a string to be printed to the terminal
+// without any intermediate processing.
+type RawMsg struct {
+ Msg any
+}
+
+// Raw is a command that prints the given string to the terminal without any
+// formatting.
+//
+// This is intended for advanced use cases where you need to query the terminal
+// or send escape sequences directly. Don't use this unless you know what
+// you're doing :)
+//
+// Example:
+//
+// func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+// switch msg := msg.(type) {
+// case input.PrimaryDeviceAttributesEvent:
+// for _, attr := range msg {
+// if attr == 4 {
+// // We have Sixel graphics support!
+// break
+// }
+// }
+// }
+//
+// // Request the terminal primary device attributes to detect Sixel graphics
+// // support.
+// return m, tea.Raw(ansi.RequestPrimaryDeviceAttributes)
+// }
+func Raw(r any) Cmd {
+ return func() Msg {
+ return RawMsg{r}
+ }
+}
diff --git a/vendor/charm.land/bubbletea/v2/renderer.go b/vendor/charm.land/bubbletea/v2/renderer.go
new file mode 100644
index 000000000..e8d792b44
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/renderer.go
@@ -0,0 +1,104 @@
+package tea
+
+import (
+ "fmt"
+
+ "github.com/charmbracelet/colorprofile"
+ "github.com/charmbracelet/x/ansi"
+)
+
+const (
+ // defaultFramerate specifies the maximum interval at which we should
+ // update the view.
+ defaultFPS = 60
+ maxFPS = 120
+)
+
+// renderer is the interface for Bubble Tea renderers.
+type renderer interface {
+ // start starts the renderer.
+ start()
+
+ // close closes the renderer and flushes any remaining data.
+ close() error
+
+ // render renders a frame to the output.
+ render(View)
+
+ // flush flushes the renderer's buffer to the output.
+ flush(closing bool) error
+
+ // reset resets the renderer's state to its initial state.
+ reset()
+
+ // insertAbove inserts unmanaged lines above the renderer.
+ insertAbove(string) error
+
+ // setSyncdUpdates sets whether to use synchronized updates.
+ setSyncdUpdates(bool)
+
+ // setWidthMethod sets the method for calculating the width of the terminal.
+ setWidthMethod(ansi.Method)
+
+ // resize notify the renderer of a terminal resize.
+ resize(int, int)
+
+ // setColorProfile sets the color profile.
+ setColorProfile(colorprofile.Profile)
+
+ // clearScreen clears the screen.
+ clearScreen()
+
+ // writeString writes a string to the renderer's output.
+ writeString(string) (int, error)
+
+ // onMouse handles a mouse event.
+ onMouse(MouseMsg) Cmd
+}
+
+type printLineMessage struct {
+ messageBody string
+}
+
+// Println prints above the Program. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Println (but similar to log.Println) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func Println(args ...any) Cmd {
+ return func() Msg {
+ return printLineMessage{
+ messageBody: fmt.Sprint(args...),
+ }
+ }
+}
+
+// Printf prints above the Program. It takes a format template followed by
+// values similar to fmt.Printf. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Printf (but similar to log.Printf) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func Printf(template string, args ...any) Cmd {
+ return func() Msg {
+ return printLineMessage{
+ messageBody: fmt.Sprintf(template, args...),
+ }
+ }
+}
+
+// encodeCursorStyle returns the integer value for the given cursor style and
+// blink state.
+func encodeCursorStyle(style CursorShape, blink bool) int {
+ // We're using the ANSI escape sequence values for cursor styles.
+ // We need to map both [style] and [steady] to the correct value.
+ style = (style * 2) + 1 //nolint:mnd
+ if !blink {
+ style++
+ }
+ return int(style)
+}
diff --git a/vendor/charm.land/bubbletea/v2/screen.go b/vendor/charm.land/bubbletea/v2/screen.go
new file mode 100644
index 000000000..f835bb376
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/screen.go
@@ -0,0 +1,68 @@
+package tea
+
+import "github.com/charmbracelet/x/ansi"
+
+// WindowSizeMsg is used to report the terminal size. It's sent to Update once
+// initially and then on every terminal resize. Note that Windows does not
+// have support for reporting when resizes occur as it does not support the
+// SIGWINCH signal.
+type WindowSizeMsg struct {
+ Width int
+ Height int
+}
+
+// ClearScreen is a special command that tells the program to clear the screen
+// before the next update. This can be used to move the cursor to the top left
+// of the screen and clear visual clutter when the alt screen is not in use.
+//
+// Note that it should never be necessary to call ClearScreen() for regular
+// redraws.
+func ClearScreen() Msg {
+ return clearScreenMsg{}
+}
+
+// clearScreenMsg is an internal message that signals to clear the screen.
+// You can send a clearScreenMsg with ClearScreen.
+type clearScreenMsg struct{}
+
+// ModeReportMsg is a message that represents a mode report event (DECRPM).
+//
+// This is sent by the terminal in response to a request for a terminal mode
+// report (DECRQM). It indicates the current setting of a specific terminal
+// mode like cursor visibility, mouse tracking, etc.
+//
+// Example:
+//
+// ```go
+// func (m model) Init() tea.Cmd {
+// // Does my terminal support reporting focus events?
+// return tea.Raw(ansi.RequestModeFocusEvent)
+// }
+//
+// func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+// switch msg := msg.(type) {
+// case tea.ModeReportMsg:
+// if msg.Mode == ansi.ModeFocusEvent && !msg.Value.IsNotRecognized() {
+// // Terminal supports focus events
+// m.supportsFocus = true
+// }
+// }
+// return m, nil
+// }
+//
+// func (m model) View() tea.View {
+// var view tea.View
+// view.ReportFocus = m.supportsFocus
+// view.SetContent(fmt.Sprintf("Terminal supports focus events: %v", m.supportsFocus))
+// return view
+// }
+// ```
+//
+// See: https://vt100.net/docs/vt510-rm/DECRPM.html
+type ModeReportMsg struct {
+ // Mode is the mode number.
+ Mode ansi.Mode
+
+ // Value is the mode value.
+ Value ansi.ModeSetting
+}
diff --git a/vendor/charm.land/bubbletea/v2/signals_unix.go b/vendor/charm.land/bubbletea/v2/signals_unix.go
new file mode 100644
index 000000000..409540385
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/signals_unix.go
@@ -0,0 +1,33 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix zos
+
+package tea
+
+import (
+ "os"
+ "os/signal"
+ "syscall"
+)
+
+// listenForResize sends messages (or errors) when the terminal resizes.
+// Argument output should be the file descriptor for the terminal; usually
+// os.Stdout.
+func (p *Program) listenForResize(done chan struct{}) {
+ sig := make(chan os.Signal, 1)
+ signal.Notify(sig, syscall.SIGWINCH)
+
+ defer func() {
+ signal.Stop(sig)
+ close(done)
+ }()
+
+ for {
+ select {
+ case <-p.ctx.Done():
+ return
+ case <-sig:
+ }
+
+ p.checkResize()
+ }
+}
diff --git a/vendor/charm.land/bubbletea/v2/signals_windows.go b/vendor/charm.land/bubbletea/v2/signals_windows.go
new file mode 100644
index 000000000..2fc6f8ae7
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/signals_windows.go
@@ -0,0 +1,10 @@
+//go:build windows
+// +build windows
+
+package tea
+
+// listenForResize is not available on windows because windows does not
+// implement syscall.SIGWINCH.
+func (p *Program) listenForResize(done chan struct{}) {
+ close(done)
+}
diff --git a/vendor/charm.land/bubbletea/v2/tea.go b/vendor/charm.land/bubbletea/v2/tea.go
new file mode 100644
index 000000000..cd98092a5
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/tea.go
@@ -0,0 +1,1437 @@
+// Package tea provides a framework for building rich terminal user interfaces
+// based on the paradigms of The Elm Architecture. It's well-suited for simple
+// and complex terminal applications, either inline, full-window, or a mix of
+// both. It's been battle-tested in several large projects and is
+// production-ready.
+//
+// A tutorial is available at https://github.com/charmbracelet/bubbletea/tree/master/tutorials
+//
+// Example programs can be found at https://github.com/charmbracelet/bubbletea/tree/master/examples
+package tea
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "fmt"
+ "image/color"
+ "io"
+ "log"
+ "os"
+ "os/signal"
+ "runtime"
+ "runtime/debug"
+ "strconv"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "syscall"
+ "time"
+
+ "github.com/charmbracelet/colorprofile"
+ uv "github.com/charmbracelet/ultraviolet"
+ "github.com/charmbracelet/x/ansi"
+ "github.com/charmbracelet/x/term"
+ "github.com/muesli/cancelreader"
+)
+
+// ErrProgramPanic is returned by [Program.Run] when the program recovers from a panic.
+var ErrProgramPanic = errors.New("program experienced a panic")
+
+// ErrProgramKilled is returned by [Program.Run] when the program gets killed.
+var ErrProgramKilled = errors.New("program was killed")
+
+// ErrInterrupted is returned by [Program.Run] when the program get a SIGINT
+// signal, or when it receives a [InterruptMsg].
+var ErrInterrupted = errors.New("program was interrupted")
+
+// Msg contain data from the result of a IO operation. Msgs trigger the update
+// function and, henceforth, the UI.
+type Msg = uv.Event
+
+// Model contains the program's state as well as its core functions.
+type Model interface {
+ // Init is the first function that will be called. It returns an optional
+ // initial command. To not perform an initial command return nil.
+ Init() Cmd
+
+ // Update is called when a message is received. Use it to inspect messages
+ // and, in response, update the model and/or send a command.
+ Update(Msg) (Model, Cmd)
+
+ // View renders the program's UI, which can be a string or a [Layer]. The
+ // view is rendered after every Update.
+ View() View
+}
+
+// NewView is a helper function to create a new [View] with the given styled
+// string. A styled string represents text with styles and hyperlinks encoded
+// as ANSI escape codes.
+//
+// Example:
+//
+// ```go
+// v := tea.NewView("Hello, World!")
+// ```
+func NewView(s string) View {
+ var view View
+ view.SetContent(s)
+ return view
+}
+
+// View represents a terminal view that can be composed of multiple layers.
+// It can also contain a cursor that will be rendered on top of the layers.
+type View struct {
+ // Content is the screen content of the view. It holds styled strings that
+ // will be rendered to the terminal when the view is rendered.
+ //
+ // A styled string represents text with styles and hyperlinks encoded as
+ // ANSI escape codes.
+ //
+ // Example:
+ //
+ // ```go
+ // v := tea.NewView("Hello, World!")
+ // ```
+ Content string
+
+ // OnMouse is an optional mouse message handler that can be used to
+ // intercept mouse messages that depends on view content from last render.
+ // It can be useful for implementing view-specific behavior without
+ // breaking the unidirectional data flow of Bubble Tea.
+ //
+ // Example:
+ //
+ // ```go
+ // content := "Hello, World!"
+ // v := tea.NewView(content)
+ // v.OnMouse = func(msg tea.MouseMsg) tea.Cmd {
+ // return func() tea.Msg {
+ // m := msg.Mouse()
+ // // Check if the mouse is within the bounds of "World!"
+ // start := strings.Index(content, "World!")
+ // end := start + len("World!")
+ // if m.Y == 0 && m.X >= start && m.X < end {
+ // // Mouse is over "World!"
+ // return MyCustomMsg{
+ // MouseMsg: msg,
+ // }
+ // }
+ // }
+ // }
+ // return nil
+ // }
+ // return v
+ // ```
+ OnMouse func(msg MouseMsg) Cmd
+
+ // Cursor represents the cursor position, style, and visibility on the
+ // screen. When not nil, the cursor will be shown at the specified
+ // position.
+ Cursor *Cursor
+
+ // BackgroundColor when not nil, sets the terminal background color. Use
+ // nil to reset to the terminal's default background color.
+ BackgroundColor color.Color
+
+ // ForegroundColor when not nil, sets the terminal foreground color. Use
+ // nil to reset to the terminal's default foreground color.
+ ForegroundColor color.Color
+
+ // WindowTitle sets the terminal window title. Support depends on the
+ // terminal.
+ WindowTitle string
+
+ // ProgressBar when not nil, shows a progress bar in the terminal's
+ // progress bar section. Support depends on the terminal.
+ ProgressBar *ProgressBar
+
+ // AltScreen puts the program in the alternate screen buffer
+ // (i.e. the program goes into full window mode). Note that the altscreen will
+ // be automatically exited when the program quits.
+ //
+ // Example:
+ //
+ // func (m model) View() tea.View {
+ // v := tea.NewView("Hello, World!")
+ // v.AltScreen = true
+ // return v
+ // }
+ //
+ AltScreen bool
+
+ // ReportFocus enables reporting when the terminal gains and loses focus.
+ // When this is enabled [FocusMsg] and [BlurMsg] messages will be sent to
+ // your Update method.
+ //
+ // Note that while most terminals and multiplexers support focus reporting,
+ // some do not. Also note that tmux needs to be configured to report focus
+ // events.
+ ReportFocus bool
+
+ // DisableBracketedPasteMode disables bracketed paste mode for this view.
+ DisableBracketedPasteMode bool
+
+ // MouseMode sets the mouse mode for this view. It can be one of
+ // [MouseModeNone], [MouseModeCellMotion], or [MouseModeAllMotion].
+ MouseMode MouseMode
+
+ // KeyboardEnhancements describes what keyboard enhancement features Bubble
+ // Tea should request from the terminal.
+ //
+ // Bubble Tea supports requesting the following keyboard enhancement features:
+ // - ReportEventTypes: requests the terminal to report key repeat and
+ // release events.
+ //
+ // If the terminal supports any of these features, your program will
+ // receive a [KeyboardEnhancementsMsg] that indicates which features are
+ // available.
+ KeyboardEnhancements KeyboardEnhancements
+}
+
+// KeyboardEnhancements describes the requested keyboard enhancement features.
+// If the terminal supports any of them, it will respond with a
+// [KeyboardEnhancementsMsg] that indicates which features are supported.
+
+// KeyboardEnhancements defines different keyboard enhancement features that
+// can be requested from the terminal.
+
+// KeyboardEnhancements defines different keyboard enhancement features that
+// can be requested from the terminal.
+//
+// By default, Bubble Tea requests basic key disambiguation features from the
+// terminal. If the terminal supports keyboard enhancements, or any of its
+// additional features, it will respond with a [KeyboardEnhancementsMsg] that
+// indicates which features are supported.
+//
+// Example:
+//
+// ```go
+// func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+// switch msg := msg.(type) {
+// case tea.KeyboardEnhancementsMsg:
+// // We have basic key disambiguation support.
+// // We can handle "shift+enter", "ctrl+i", etc.
+// m.keyboardEnhancements = msg
+// if msg.ReportEventTypes {
+// // Even better! We can now handle key repeat and release events.
+// }
+// case tea.KeyPressMsg:
+// switch msg.String() {
+// case "shift+enter":
+// // Handle shift+enter
+// // This would not be possible without keyboard enhancements.
+// case "ctrl+j":
+// // Handle ctrl+j
+// }
+// case tea.KeyReleaseMsg:
+// // Whoa! A key was released!
+// }
+//
+// return m, nil
+// }
+//
+// func (m model) View() tea.View {
+// v := tea.NewView("Press some keys!")
+// // Request reporting key repeat and release events.
+// v.KeyboardEnhancements.ReportEventTypes = true
+// return v
+// }
+// ```
+type KeyboardEnhancements struct {
+ // ReportEventTypes requests the terminal to report key repeat and release
+ // events.
+ // If supported, your program will receive [KeyReleaseMsg]s and
+ // [KeyPressMsg] with the [Key.IsRepeat] field set indicating that this is
+ // a it's part of a key repeat sequence.
+ ReportEventTypes bool
+
+ // ReportAlternateKeys requests the terminal to report alternate key values
+ // in addition to the main ones.
+ // Note that only key events represented as escape codes will affected by
+ // this enhancement.
+ ReportAlternateKeys bool
+
+ // ReportAllKeysAsEscapeCodes requests the terminal to report all key
+ // events, including plain text keys, as escape codes.
+ // When this is enabled, text won't be sent as plain text but instead as
+ // escape codes that encode the key value and modifiers.
+ ReportAllKeysAsEscapeCodes bool
+
+ // ReportAssociatedText requests the terminal to report the text associated
+ // with key events.
+ // Note that this is an enhancement to
+ // [KeyboardEnhancements.ReportAllKeysAsEscapeCodes] and only has an effect
+ // if that is enabled.
+ ReportAssociatedText bool
+}
+
+// SetContent is a helper method to set the content of a [View] with a styled
+// string. A styled string represents text with styles and hyperlinks encoded
+// as ANSI escape codes.
+//
+// Example:
+//
+// ```go
+// var v tea.View
+// v.SetContent("Hello, World!")
+// ```
+func (v *View) SetContent(s string) {
+ v.Content = s
+}
+
+// MouseMode represents the mouse mode of a view.
+type MouseMode int
+
+const (
+ // MouseModeNone disables mouse events.
+ MouseModeNone MouseMode = iota
+
+ // MouseModeCellMotion enables mouse click, release, and wheel events.
+ // Mouse movement events are also captured if a mouse button is pressed
+ // (i.e., drag events). Cell motion mode is better supported than all
+ // motion mode.
+ //
+ // This will try to enable the mouse in extended mode (SGR), if that is not
+ // supported by the terminal it will fall back to normal mode (X10).
+ MouseModeCellMotion
+
+ // MouseModeAllMotion enables all mouse events, including click, release,
+ // wheel, and movement events. You will receive mouse movement events even
+ // when no buttons are pressed.
+ //
+ // This will try to enable the mouse in extended mode (SGR), if that is not
+ // supported by the terminal it will fall back to normal mode (X10).
+ MouseModeAllMotion
+)
+
+// ProgressBarState represents the state of the progress bar.
+type ProgressBarState int
+
+// Progress bar states.
+const (
+ ProgressBarNone ProgressBarState = iota
+ ProgressBarDefault
+ ProgressBarError
+ ProgressBarIndeterminate
+ ProgressBarWarning
+)
+
+// String return a human-readable value for the given [ProgressBarState].
+func (s ProgressBarState) String() string {
+ return [...]string{
+ "None",
+ "Default",
+ "Error",
+ "Indeterminate",
+ "Warning",
+ }[s]
+}
+
+// ProgressBar represents the terminal progress bar.
+//
+// Support depends on the terminal.
+//
+// See https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences
+type ProgressBar struct {
+ // State is the current state of the progress bar. It can be one of
+ // [ProgressBarNone], [ProgressBarDefault], [ProgressBarError],
+ // [ProgressBarIndeterminate], and [ProgressBarWarn].
+ State ProgressBarState
+ // Value is the current value of the progress bar. It should be between
+ // 0 and 100.
+ Value int
+}
+
+// NewProgressBar returns a new progress bar with the given state and value.
+// The value is ignored if the state is [ProgressBarNone] or
+// [ProgressBarIndeterminate].
+func NewProgressBar(state ProgressBarState, value int) *ProgressBar {
+ return &ProgressBar{
+ State: state,
+ Value: min(max(value, 0), 100),
+ }
+}
+
+// Cursor represents a cursor on the terminal screen.
+type Cursor struct {
+ // Position is a [Position] that determines the cursor's position on the
+ // screen relative to the top left corner of the frame.
+ Position
+
+ // Color is a [color.Color] that determines the cursor's color.
+ Color color.Color
+
+ // Shape is a [CursorShape] that determines the cursor's shape.
+ Shape CursorShape
+
+ // Blink is a boolean that determines whether the cursor should blink.
+ Blink bool
+}
+
+// NewCursor returns a new cursor with the default settings and the given
+// position.
+func NewCursor(x, y int) *Cursor {
+ return &Cursor{
+ Position: Position{X: x, Y: y},
+ Color: nil,
+ Shape: CursorBlock,
+ Blink: true,
+ }
+}
+
+// Cmd is an IO operation that returns a message when it's complete. If it's
+// nil it's considered a no-op. Use it for things like HTTP requests, timers,
+// saving and loading from disk, and so on.
+//
+// Note that there's almost never a reason to use a command to send a message
+// to another part of your program. That can almost always be done in the
+// update function.
+type Cmd func() Msg
+
+// channelHandlers manages the series of channels returned by various processes.
+// It allows us to wait for those processes to terminate before exiting the
+// program.
+type channelHandlers struct {
+ handlers []chan struct{}
+ mu sync.RWMutex
+}
+
+// Adds a channel to the list of handlers. We wait for all handlers to terminate
+// gracefully on shutdown.
+func (h *channelHandlers) add(ch chan struct{}) {
+ h.mu.Lock()
+ h.handlers = append(h.handlers, ch)
+ h.mu.Unlock()
+}
+
+// shutdown waits for all handlers to terminate.
+func (h *channelHandlers) shutdown() {
+ var wg sync.WaitGroup
+
+ h.mu.RLock()
+ defer h.mu.RUnlock()
+
+ for _, ch := range h.handlers {
+ wg.Add(1)
+ go func(ch chan struct{}) {
+ <-ch
+ wg.Done()
+ }(ch)
+ }
+ wg.Wait()
+}
+
+// Program is a terminal user interface.
+type Program struct {
+ // disableInput disables all input. This is useful for programs that
+ // don't need input, like a progress bar or a spinner.
+ disableInput bool
+
+ // disableSignalHandler disables the signal handler that Bubble Tea sets up
+ // for Programs. This is useful if you want to handle signals yourself.
+ disableSignalHandler bool
+
+ // disableCatchPanics disables the panic catching that Bubble Tea does by
+ // default. If panic catching is disabled the terminal will be in a fairly
+ // unusable state after a panic because Bubble Tea will not perform its usual
+ // cleanup on exit.
+ disableCatchPanics bool
+
+ // filter supplies an event filter that will be invoked before Bubble Tea
+ // processes a tea.Msg. The event filter can return any tea.Msg which will
+ // then get handled by Bubble Tea instead of the original event. If the
+ // event filter returns nil, the event will be ignored and Bubble Tea will
+ // not process it.
+ //
+ // As an example, this could be used to prevent a program from shutting
+ // down if there are unsaved changes.
+ //
+ // Example:
+ //
+ // func filter(m tea.Model, msg tea.Msg) tea.Msg {
+ // if _, ok := msg.(tea.QuitMsg); !ok {
+ // return msg
+ // }
+ //
+ // model := m.(myModel)
+ // if model.hasChanges {
+ // return nil
+ // }
+ //
+ // return msg
+ // }
+ //
+ // p := tea.NewProgram(Model{});
+ // p.filter = filter
+ //
+ // if _,err := p.Run(context.Background()); err != nil {
+ // fmt.Println("Error running program:", err)
+ // os.Exit(1)
+ // }
+ filter func(Model, Msg) Msg
+
+ // fps sets a custom maximum fps at which the renderer should run. If less
+ // than 1, the default value of 60 will be used. If over 120, the fps will
+ // be capped at 120.
+ fps int
+
+ // initialModel is the initial model for the program and is the only
+ // required field when creating a new program.
+ initialModel Model
+
+ // disableRenderer prevents the program from rendering to the terminal.
+ // This can be useful for running daemon-like programs that don't require a
+ // UI but still want to take advantage of Bubble Tea's architecture.
+ disableRenderer bool
+
+ // handlers is a list of channels that need to be waited on before the
+ // program can exit.
+ handlers channelHandlers
+
+ // ctx is the programs's internal context for signalling internal teardown.
+ // It is built and derived from the externalCtx in NewProgram().
+ ctx context.Context
+ cancel context.CancelFunc
+
+ // externalCtx is a context that was passed in via WithContext, otherwise defaulting
+ // to ctx.Background() (in case it was not), the internal context is derived from it.
+ externalCtx context.Context
+
+ msgs chan Msg
+ errs chan error
+ finished chan struct{}
+ shutdownOnce sync.Once
+
+ profile *colorprofile.Profile // the terminal color profile
+
+ // where to send output, this will usually be os.Stdout.
+ output io.Writer
+ outputBuf bytes.Buffer // buffer used to queue commands to be sent to the output
+
+ // ttyOutput is null if output is not a TTY.
+ ttyOutput term.File
+ previousOutputState *term.State
+ renderer renderer
+
+ // the environment variables for the program, defaults to os.Environ().
+ environ uv.Environ
+ // the program's logger for debugging.
+ logger uv.Logger
+
+ // where to read inputs from, this will usually be os.Stdin.
+ input io.Reader
+ // ttyInput is null if input is not a TTY.
+ ttyInput term.File
+ previousTtyInputState *term.State
+ cancelReader cancelreader.CancelReader
+ inputScanner *uv.TerminalReader
+ readLoopDone chan struct{}
+
+ // modes keeps track of terminal modes that have been enabled or disabled.
+ ignoreSignals uint32
+
+ // ticker is the ticker that will be used to write to the renderer.
+ ticker *time.Ticker
+
+ // once is used to stop the renderer.
+ once sync.Once
+
+ // rendererDone is used to stop the renderer.
+ rendererDone chan struct{}
+
+ // Initial window size. Mainly used for testing.
+ width, height int
+
+ // whether to use hard tabs to optimize cursor movements
+ useHardTabs bool
+ // whether to use backspace to optimize cursor movements
+ useBackspace bool
+
+ mu sync.Mutex
+}
+
+// Quit is a special command that tells the Bubble Tea program to exit.
+func Quit() Msg {
+ return QuitMsg{}
+}
+
+// QuitMsg signals that the program should quit. You can send a [QuitMsg] with
+// [Quit].
+type QuitMsg struct{}
+
+// Suspend is a special command that tells the Bubble Tea program to suspend.
+func Suspend() Msg {
+ return SuspendMsg{}
+}
+
+// SuspendMsg signals the program should suspend.
+// This usually happens when ctrl+z is pressed on common programs, but since
+// bubbletea puts the terminal in raw mode, we need to handle it in a
+// per-program basis.
+//
+// You can send this message with [Suspend()].
+type SuspendMsg struct{}
+
+// ResumeMsg can be listen to do something once a program is resumed back
+// from a suspend state.
+type ResumeMsg struct{}
+
+// InterruptMsg signals the program should suspend.
+// This usually happens when ctrl+c is pressed on common programs, but since
+// bubbletea puts the terminal in raw mode, we need to handle it in a
+// per-program basis.
+//
+// You can send this message with [Interrupt()].
+type InterruptMsg struct{}
+
+// Interrupt is a special command that tells the Bubble Tea program to
+// interrupt.
+func Interrupt() Msg {
+ return InterruptMsg{}
+}
+
+// NewProgram creates a new [Program].
+func NewProgram(model Model, opts ...ProgramOption) *Program {
+ p := &Program{
+ initialModel: model,
+ msgs: make(chan Msg),
+ errs: make(chan error, 1),
+ rendererDone: make(chan struct{}),
+ }
+
+ // Apply all options to the program.
+ for _, opt := range opts {
+ opt(p)
+ }
+
+ // A context can be provided with a ProgramOption, but if none was provided
+ // we'll use the default background context.
+ if p.externalCtx == nil {
+ p.externalCtx = context.Background()
+ }
+ // Initialize context and teardown channel.
+ p.ctx, p.cancel = context.WithCancel(p.externalCtx)
+
+ // if no output was set, set it to stdout
+ if p.output == nil {
+ p.output = os.Stdout
+ }
+
+ // if no environment was set, set it to os.Environ()
+ if p.environ == nil {
+ p.environ = os.Environ()
+ }
+
+ if p.fps < 1 {
+ p.fps = defaultFPS
+ } else if p.fps > maxFPS {
+ p.fps = maxFPS
+ }
+
+ tracePath, traceOk := os.LookupEnv("TEA_TRACE")
+ if traceOk && len(tracePath) > 0 {
+ // We have a trace filepath.
+ if f, err := os.OpenFile(tracePath, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0o600); err == nil {
+ p.logger = log.New(f, "bubbletea: ", log.LstdFlags|log.Lshortfile)
+ }
+ }
+
+ return p
+}
+
+func (p *Program) handleSignals() chan struct{} {
+ ch := make(chan struct{})
+
+ // Listen for SIGINT and SIGTERM.
+ //
+ // In most cases ^C will not send an interrupt because the terminal will be
+ // in raw mode and ^C will be captured as a keystroke and sent along to
+ // Program.Update as a KeyMsg. When input is not a TTY, however, ^C will be
+ // caught here.
+ //
+ // SIGTERM is sent by unix utilities (like kill) to terminate a process.
+ go func() {
+ sig := make(chan os.Signal, 1)
+ signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+ defer func() {
+ signal.Stop(sig)
+ close(ch)
+ }()
+
+ for {
+ select {
+ case <-p.ctx.Done():
+ return
+
+ case s := <-sig:
+ if atomic.LoadUint32(&p.ignoreSignals) == 0 {
+ switch s {
+ case syscall.SIGINT:
+ p.msgs <- InterruptMsg{}
+ default:
+ p.msgs <- QuitMsg{}
+ }
+ return
+ }
+ }
+ }
+ }()
+
+ return ch
+}
+
+// handleResize handles terminal resize events.
+func (p *Program) handleResize() chan struct{} {
+ ch := make(chan struct{})
+
+ if p.ttyOutput != nil {
+ // Listen for window resizes.
+ go p.listenForResize(ch)
+ } else {
+ close(ch)
+ }
+
+ return ch
+}
+
+// handleCommands runs commands in a goroutine and sends the result to the
+// program's message channel.
+func (p *Program) handleCommands(cmds chan Cmd) chan struct{} {
+ ch := make(chan struct{})
+
+ go func() {
+ defer close(ch)
+
+ for {
+ select {
+ case <-p.ctx.Done():
+ return
+
+ case cmd := <-cmds:
+ if cmd == nil {
+ continue
+ }
+
+ // Don't wait on these goroutines, otherwise the shutdown
+ // latency would get too large as a Cmd can run for some time
+ // (e.g. tick commands that sleep for half a second). It's not
+ // possible to cancel them so we'll have to leak the goroutine
+ // until Cmd returns.
+ go func() {
+ // Recover from panics.
+ if !p.disableCatchPanics {
+ defer func() {
+ if r := recover(); r != nil {
+ p.recoverFromPanic(r)
+ }
+ }()
+ }
+
+ msg := cmd() // this can be long.
+ p.Send(msg)
+ }()
+ }
+ }
+ }()
+
+ return ch
+}
+
+// eventLoop is the central message loop. It receives and handles the default
+// Bubble Tea messages, update the model and triggers redraws.
+func (p *Program) eventLoop(model Model, cmds chan Cmd) (Model, error) {
+ for {
+ select {
+ case <-p.ctx.Done():
+ return model, nil
+
+ case err := <-p.errs:
+ return model, err
+
+ case msg := <-p.msgs:
+ msg = p.translateInputEvent(msg)
+
+ // Filter messages.
+ if p.filter != nil {
+ msg = p.filter(model, msg)
+ }
+ if msg == nil {
+ continue
+ }
+
+ // Handle special internal messages.
+ switch msg := msg.(type) {
+ case QuitMsg:
+ return model, nil
+
+ case InterruptMsg:
+ return model, ErrInterrupted
+
+ case SuspendMsg:
+ if suspendSupported {
+ p.suspend()
+ }
+
+ case CapabilityMsg:
+ switch msg.Content {
+ case "RGB", "Tc":
+ if *p.profile != colorprofile.TrueColor {
+ tc := colorprofile.TrueColor
+ p.profile = &tc
+ go p.Send(ColorProfileMsg{*p.profile})
+ }
+ }
+
+ case ModeReportMsg:
+ switch msg.Mode {
+ case ansi.ModeSynchronizedOutput:
+ if msg.Value == ansi.ModeReset {
+ // The terminal supports synchronized output and it's
+ // currently disabled, so we can enable it on the renderer.
+ p.renderer.setSyncdUpdates(true)
+ }
+ case ansi.ModeUnicodeCore:
+ if msg.Value == ansi.ModeReset || msg.Value == ansi.ModeSet || msg.Value == ansi.ModePermanentlySet {
+ p.renderer.setWidthMethod(ansi.GraphemeWidth)
+ }
+ }
+
+ case MouseMsg:
+ switch msg.(type) {
+ case MouseClickMsg, MouseReleaseMsg, MouseWheelMsg, MouseMotionMsg:
+ // Only send mouse messages to the renderer if they are an
+ // actual mouse event.
+ if cmd := p.renderer.onMouse(msg); cmd != nil {
+ go p.Send(cmd())
+ }
+ }
+
+ case readClipboardMsg:
+ p.execute(ansi.RequestSystemClipboard)
+
+ case setClipboardMsg:
+ p.execute(ansi.SetSystemClipboard(string(msg)))
+
+ case readPrimaryClipboardMsg:
+ p.execute(ansi.RequestPrimaryClipboard)
+
+ case setPrimaryClipboardMsg:
+ p.execute(ansi.SetPrimaryClipboard(string(msg)))
+
+ case backgroundColorMsg:
+ p.execute(ansi.RequestBackgroundColor)
+
+ case foregroundColorMsg:
+ p.execute(ansi.RequestForegroundColor)
+
+ case cursorColorMsg:
+ p.execute(ansi.RequestCursorColor)
+
+ case execMsg:
+ // NB: this blocks.
+ p.exec(msg.cmd, msg.fn)
+
+ case terminalVersion:
+ p.execute(ansi.RequestNameVersion)
+
+ case requestCapabilityMsg:
+ p.execute(ansi.RequestTermcap(string(msg)))
+
+ case BatchMsg:
+ go p.execBatchMsg(msg)
+ continue
+
+ case sequenceMsg:
+ go p.execSequenceMsg(msg)
+ continue
+
+ case WindowSizeMsg:
+ p.renderer.resize(msg.Width, msg.Height)
+
+ case windowSizeMsg:
+ go p.checkResize()
+
+ case requestCursorPosMsg:
+ p.execute(ansi.RequestCursorPositionReport)
+
+ case RawMsg:
+ p.execute(fmt.Sprint(msg.Msg))
+
+ case printLineMessage:
+ p.renderer.insertAbove(msg.messageBody) //nolint:errcheck,gosec
+
+ case clearScreenMsg:
+ p.renderer.clearScreen()
+
+ case ColorProfileMsg:
+ p.renderer.setColorProfile(msg.Profile)
+ }
+
+ var cmd Cmd
+ model, cmd = model.Update(msg) // run update
+
+ select {
+ case <-p.ctx.Done():
+ return model, nil
+ case cmds <- cmd: // process command (if any)
+ }
+
+ p.render(model) // render view
+ }
+ }
+}
+
+// render renders the given view to the renderer.
+func (p *Program) render(model Model) {
+ if p.renderer != nil {
+ p.renderer.render(model.View()) // send view to renderer
+ }
+}
+
+func (p *Program) execSequenceMsg(msg sequenceMsg) {
+ if !p.disableCatchPanics {
+ defer func() {
+ if r := recover(); r != nil {
+ p.recoverFromGoPanic(r)
+ }
+ }()
+ }
+
+ // Execute commands one at a time, in order.
+ for _, cmd := range msg {
+ if cmd == nil {
+ continue
+ }
+ msg := cmd()
+ switch msg := msg.(type) {
+ case BatchMsg:
+ p.execBatchMsg(msg)
+ case sequenceMsg:
+ p.execSequenceMsg(msg)
+ default:
+ p.Send(msg)
+ }
+ }
+}
+
+func (p *Program) execBatchMsg(msg BatchMsg) {
+ if !p.disableCatchPanics {
+ defer func() {
+ if r := recover(); r != nil {
+ p.recoverFromGoPanic(r)
+ }
+ }()
+ }
+
+ // Execute commands one at a time.
+ var wg sync.WaitGroup
+ for _, cmd := range msg {
+ if cmd == nil {
+ continue
+ }
+ wg.Add(1)
+ go func() {
+ defer wg.Done()
+
+ if !p.disableCatchPanics {
+ defer func() {
+ if r := recover(); r != nil {
+ p.recoverFromGoPanic(r)
+ }
+ }()
+ }
+
+ msg := cmd()
+ switch msg := msg.(type) {
+ case BatchMsg:
+ p.execBatchMsg(msg)
+ case sequenceMsg:
+ p.execSequenceMsg(msg)
+ default:
+ p.Send(msg)
+ }
+ }()
+ }
+
+ wg.Wait() // wait for all commands from batch msg to finish
+}
+
+// shouldQuerySynchronizedOutput determines whether the terminal should be
+// queried for various capabilities.
+//
+// This function checks for terminals that are known to support mode 2026,
+// while excluding SSH sessions which may be unreliable, unless it's a
+// known-good terminal like Windows Terminal.
+//
+// The function returns true for:
+// - Terminals without TERM_PROGRAM set and not in SSH sessions
+// - Windows Terminal (WT_SESSION is set)
+// - Terminals with TERM_PROGRAM set (except Apple Terminal) and not in SSH sessions
+// - Specific terminal types: ghostty, wezterm, alacritty, kitty, rio
+func shouldQuerySynchronizedOutput(environ uv.Environ) bool {
+ termType := environ.Getenv("TERM")
+ termProg, okTermProg := environ.LookupEnv("TERM_PROGRAM")
+ _, okSSHTTY := environ.LookupEnv("SSH_TTY")
+ _, okWTSession := environ.LookupEnv("WT_SESSION")
+
+ return (!okTermProg && !okSSHTTY) ||
+ okWTSession ||
+ (okTermProg && !strings.Contains(termProg, "Apple") && !okSSHTTY) ||
+ strings.Contains(termType, "ghostty") ||
+ strings.Contains(termType, "wezterm") ||
+ strings.Contains(termType, "alacritty") ||
+ strings.Contains(termType, "kitty") ||
+ strings.Contains(termType, "rio")
+}
+
+// Run initializes the program and runs its event loops, blocking until it gets
+// terminated by either [Program.Quit], [Program.Kill], or its signal handler.
+// Returns the final model.
+func (p *Program) Run() (returnModel Model, returnErr error) {
+ if p.initialModel == nil {
+ return nil, errors.New("bubbletea: InitialModel cannot be nil")
+ }
+
+ // Initialize context and teardown channel.
+ p.handlers = channelHandlers{}
+ cmds := make(chan Cmd)
+
+ p.finished = make(chan struct{})
+ defer func() {
+ close(p.finished)
+ }()
+
+ defer p.cancel()
+
+ if p.disableInput {
+ p.input = nil
+ } else if p.input == nil {
+ p.input = os.Stdin
+ if !term.IsTerminal(os.Stdin.Fd()) {
+ ttyIn, _, err := OpenTTY()
+ if err != nil {
+ return p.initialModel, fmt.Errorf("bubbletea: error opening TTY: %w", err)
+ }
+ p.input = ttyIn
+ }
+ }
+
+ // Handle signals.
+ if !p.disableSignalHandler {
+ p.handlers.add(p.handleSignals())
+ }
+
+ // Recover from panics.
+ if !p.disableCatchPanics {
+ defer func() {
+ if r := recover(); r != nil {
+ returnErr = fmt.Errorf("%w: %w", ErrProgramKilled, ErrProgramPanic)
+ p.recoverFromPanic(r)
+ }
+ }()
+ }
+
+ // Check if output is a TTY before entering raw mode, hiding the cursor and
+ // so on.
+ if err := p.initTerminal(); err != nil {
+ return p.initialModel, err
+ }
+
+ // Get the initial window size.
+ width, height := p.width, p.height
+ if p.ttyOutput != nil {
+ // Set the initial size of the terminal.
+ w, h, err := term.GetSize(p.ttyOutput.Fd())
+ if err != nil {
+ return p.initialModel, fmt.Errorf("bubbletea: error getting terminal size: %w", err)
+ }
+
+ width, height = w, h
+ }
+
+ p.width, p.height = width, height
+ resizeMsg := WindowSizeMsg{Width: p.width, Height: p.height}
+
+ if p.renderer == nil {
+ if p.disableRenderer {
+ p.renderer = &nilRenderer{}
+ } else {
+ // If no renderer is set use the cursed one.
+ r := newCursedRenderer(
+ p.output,
+ p.environ,
+ p.width,
+ p.height,
+ )
+ r.setLogger(p.logger)
+ // XXX: This breaks many things especially when we want the output
+ // to be compatible with terminals that are not necessary a TTY.
+ // This was originally done to work around a Wish emulated-pty
+ // issue where when a PTY session is detected, and we don't
+ // allocate a real PTY, the terminal settings (Termios and WinCon)
+ // don't change and the we end up working in cooked mode instead of
+ // raw mode. See issue #1572.
+ mapNl := runtime.GOOS != "windows" && p.ttyInput == nil
+ r.setOptimizations(p.useHardTabs, p.useBackspace, mapNl)
+ p.renderer = r
+ }
+ }
+
+ // Get the color profile and send it to the program.
+ if p.profile == nil {
+ cp := colorprofile.Detect(p.output, p.environ)
+ p.profile = &cp
+ }
+
+ // Set the color profile on the renderer and send it to the program.
+ p.renderer.setColorProfile(*p.profile)
+ go p.Send(ColorProfileMsg{*p.profile})
+
+ // Send the initial size to the program.
+ go p.Send(resizeMsg)
+ p.renderer.resize(resizeMsg.Width, resizeMsg.Height)
+
+ // Send the environment variables used by the program.
+ go p.Send(EnvMsg(p.environ))
+
+ // Init the input reader and initial model.
+ model := p.initialModel
+ if p.input != nil {
+ if err := p.initInputReader(false); err != nil {
+ return model, err
+ }
+ }
+
+ // Start the renderer.
+ p.startRenderer()
+
+ if !p.disableRenderer && shouldQuerySynchronizedOutput(p.environ) {
+ // Query for synchronized updates support (mode 2026) and unicode core
+ // (mode 2027). If the terminal supports it, the renderer will enable
+ // it once we get the response.
+ p.execute(ansi.RequestModeSynchronizedOutput +
+ ansi.RequestModeUnicodeCore)
+ }
+
+ // Initialize the program.
+ initCmd := model.Init()
+ if initCmd != nil {
+ ch := make(chan struct{})
+ p.handlers.add(ch)
+
+ go func() {
+ defer close(ch)
+
+ select {
+ case cmds <- initCmd:
+ case <-p.ctx.Done():
+ }
+ }()
+ }
+
+ // Render the initial view.
+ p.render(model)
+
+ // Handle resize events.
+ p.handlers.add(p.handleResize())
+
+ // Process commands.
+ p.handlers.add(p.handleCommands(cmds))
+
+ // Run event loop, handle updates and draw.
+ var err error
+ model, err = p.eventLoop(model, cmds)
+
+ if err == nil && len(p.errs) > 0 {
+ err = <-p.errs // Drain a leftover error in case eventLoop crashed.
+ }
+
+ killed := p.externalCtx.Err() != nil || p.ctx.Err() != nil || err != nil
+ if killed {
+ if err == nil && p.externalCtx.Err() != nil {
+ // Return also as context error the cancellation of an external context.
+ // This is the context the user knows about and should be able to act on.
+ err = fmt.Errorf("%w: %w", ErrProgramKilled, p.externalCtx.Err())
+ } else if err == nil && p.ctx.Err() != nil {
+ // Return only that the program was killed (not the internal mechanism).
+ // The user does not know or need to care about the internal program context.
+ err = ErrProgramKilled
+ } else {
+ // Return that the program was killed and also the error that caused it.
+ err = fmt.Errorf("%w: %w", ErrProgramKilled, err)
+ }
+ } else {
+ // Graceful shutdown of the program (not killed):
+ // Ensure we rendered the final state of the model.
+ p.render(model)
+ }
+
+ // Restore terminal state.
+ p.shutdown(killed)
+
+ return model, err
+}
+
+// Send sends a message to the main update function, effectively allowing
+// messages to be injected from outside the program for interoperability
+// purposes.
+//
+// If the program hasn't started yet this will be a blocking operation.
+// If the program has already been terminated this will be a no-op, so it's safe
+// to send messages after the program has exited.
+func (p *Program) Send(msg Msg) {
+ select {
+ case <-p.ctx.Done():
+ case p.msgs <- msg:
+ }
+}
+
+// Quit is a convenience function for quitting Bubble Tea programs. Use it
+// when you need to shut down a Bubble Tea program from the outside.
+//
+// If you wish to quit from within a Bubble Tea program use the Quit command.
+//
+// If the program is not running this will be a no-op, so it's safe to call
+// if the program is unstarted or has already exited.
+func (p *Program) Quit() {
+ p.Send(Quit())
+}
+
+// Kill stops the program immediately and restores the former terminal state.
+// The final render that you would normally see when quitting will be skipped.
+// [program.Run] returns a [ErrProgramKilled] error.
+func (p *Program) Kill() {
+ p.shutdown(true)
+}
+
+// Wait waits/blocks until the underlying Program finished shutting down.
+func (p *Program) Wait() {
+ <-p.finished
+}
+
+// execute writes the given sequence to the program output.
+func (p *Program) execute(seq string) {
+ p.mu.Lock()
+ _, _ = p.outputBuf.WriteString(seq)
+ p.mu.Unlock()
+}
+
+// flush flushes the output buffer to the program output.
+func (p *Program) flush() error {
+ p.mu.Lock()
+ defer p.mu.Unlock()
+
+ if p.outputBuf.Len() == 0 {
+ return nil
+ }
+ if p.logger != nil {
+ p.logger.Printf("output: %q", p.outputBuf.String())
+ }
+ _, err := p.output.Write(p.outputBuf.Bytes())
+ p.outputBuf.Reset()
+ if err != nil {
+ return fmt.Errorf("error writing to output: %w", err)
+ }
+ return nil
+}
+
+// shutdown performs operations to free up resources and restore the terminal
+// to its original state.
+func (p *Program) shutdown(kill bool) {
+ p.shutdownOnce.Do(func() {
+ p.cancel()
+
+ // Wait for all handlers to finish.
+ p.handlers.shutdown()
+
+ // Check if the cancel reader has been setup before waiting and closing.
+ if p.cancelReader != nil {
+ // Wait for input loop to finish.
+ if p.cancelReader.Cancel() {
+ if !kill {
+ p.waitForReadLoop()
+ }
+ }
+ _ = p.cancelReader.Close()
+ }
+
+ if p.renderer != nil {
+ p.stopRenderer(kill)
+ }
+
+ _ = p.restoreTerminalState()
+ })
+}
+
+// recoverFromPanic recovers from a panic, prints the stack trace, and restores
+// the terminal to a usable state.
+func (p *Program) recoverFromPanic(r interface{}) {
+ select {
+ case p.errs <- ErrProgramPanic:
+ default:
+ }
+ p.shutdown(true) // Ok to call here, p.Run() cannot do it anymore.
+ // We use "\r\n" to ensure the output is formatted even when restoring the
+ // terminal does not work or when raw mode is still active.
+ rec := strings.ReplaceAll(fmt.Sprintf("%s", r), "\n", "\r\n")
+ fmt.Fprintf(os.Stderr, "Caught panic:\r\n\r\n%s\r\n\r\nRestoring terminal...\r\n\r\n", rec)
+ stack := strings.ReplaceAll(fmt.Sprintf("%s\n", debug.Stack()), "\n", "\r\n")
+ fmt.Fprint(os.Stderr, stack)
+ if v, err := strconv.ParseBool(os.Getenv("TEA_DEBUG")); err == nil && v {
+ f, err := os.Create(fmt.Sprintf("bubbletea-panic-%d.log", time.Now().Unix()))
+ if err == nil {
+ defer f.Close() //nolint:errcheck
+ fmt.Fprintln(f, rec) //nolint:errcheck
+ fmt.Fprintln(f) //nolint:errcheck
+ fmt.Fprintln(f, stack) //nolint:errcheck
+ }
+ }
+}
+
+// recoverFromGoPanic recovers from a goroutine panic, prints a stack trace and
+// signals for the program to be killed and terminal restored to a usable state.
+func (p *Program) recoverFromGoPanic(r interface{}) {
+ select {
+ case p.errs <- ErrProgramPanic:
+ default:
+ }
+ p.cancel()
+ // We use "\r\n" to ensure the output is formatted even when restoring the
+ // terminal does not work or when raw mode is still active.
+ rec := strings.ReplaceAll(fmt.Sprintf("%s", r), "\n", "\r\n")
+ fmt.Fprintf(os.Stderr, "Caught panic:\r\n\r\n%s\r\n\r\nRestoring terminal...\r\n\r\n", rec)
+ stack := strings.ReplaceAll(fmt.Sprintf("%s\n", debug.Stack()), "\n", "\r\n")
+ fmt.Fprint(os.Stderr, stack)
+ if v, err := strconv.ParseBool(os.Getenv("TEA_DEBUG")); err == nil && v {
+ f, err := os.Create(fmt.Sprintf("bubbletea-panic-%d.log", time.Now().Unix()))
+ if err == nil {
+ defer f.Close() //nolint:errcheck
+ fmt.Fprintln(f, rec) //nolint:errcheck
+ fmt.Fprintln(f) //nolint:errcheck
+ fmt.Fprintln(f, stack) //nolint:errcheck
+ }
+ }
+}
+
+// ReleaseTerminal restores the original terminal state and cancels the input
+// reader. You can return control to the Program with RestoreTerminal.
+func (p *Program) ReleaseTerminal() error {
+ return p.releaseTerminal(false)
+}
+
+func (p *Program) releaseTerminal(reset bool) error {
+ atomic.StoreUint32(&p.ignoreSignals, 1)
+ if p.cancelReader != nil {
+ p.cancelReader.Cancel()
+ }
+
+ p.waitForReadLoop()
+
+ if p.renderer != nil {
+ p.stopRenderer(false)
+ if reset {
+ p.renderer.reset()
+ }
+ }
+
+ return p.restoreTerminalState()
+}
+
+// RestoreTerminal reinitializes the Program's input reader, restores the
+// terminal to the former state when the program was running, and repaints.
+// Use it to reinitialize a Program after running ReleaseTerminal.
+func (p *Program) RestoreTerminal() error {
+ atomic.StoreUint32(&p.ignoreSignals, 0)
+
+ if err := p.initTerminal(); err != nil {
+ return err
+ }
+ if err := p.initInputReader(false); err != nil {
+ return err
+ }
+
+ p.startRenderer()
+
+ // If the output is a terminal, it may have been resized while another
+ // process was at the foreground, in which case we may not have received
+ // SIGWINCH. Detect any size change now and propagate the new size as
+ // needed.
+ go p.checkResize()
+
+ // Flush queued commands.
+ return p.flush()
+}
+
+// Println prints above the Program. This output is unmanaged by the program
+// and will persist across renders by the Program.
+//
+// If the altscreen is active no output will be printed.
+func (p *Program) Println(args ...any) {
+ p.msgs <- printLineMessage{
+ messageBody: fmt.Sprint(args...),
+ }
+}
+
+// Printf prints above the Program. It takes a format template followed by
+// values similar to fmt.Printf. This output is unmanaged by the program and
+// will persist across renders by the Program.
+//
+// Unlike fmt.Printf (but similar to log.Printf) the message will be print on
+// its own line.
+//
+// If the altscreen is active no output will be printed.
+func (p *Program) Printf(template string, args ...any) {
+ p.msgs <- printLineMessage{
+ messageBody: fmt.Sprintf(template, args...),
+ }
+}
+
+// startRenderer starts the renderer.
+func (p *Program) startRenderer() {
+ framerate := time.Second / time.Duration(p.fps)
+ if p.ticker == nil {
+ p.ticker = time.NewTicker(framerate)
+ } else {
+ // If the ticker already exists, it has been stopped and we need to
+ // reset it.
+ p.ticker.Reset(framerate)
+ }
+
+ // Since the renderer can be restarted after a stop, we need to reset
+ // the done channel and its corresponding sync.Once.
+ p.once = sync.Once{}
+
+ // Start the renderer.
+ p.renderer.start()
+ go func() {
+ for {
+ select {
+ case <-p.rendererDone:
+ p.ticker.Stop()
+ return
+
+ case <-p.ticker.C:
+ _ = p.flush()
+ _ = p.renderer.flush(false)
+ }
+ }
+ }()
+}
+
+// stopRenderer stops the renderer.
+// If kill is true, the renderer will be stopped immediately without flushing
+// the last frame.
+func (p *Program) stopRenderer(kill bool) {
+ // Stop the renderer before acquiring the mutex to avoid a deadlock.
+ p.once.Do(func() {
+ p.rendererDone <- struct{}{}
+ })
+
+ if !kill {
+ // flush locks the mutex
+ _ = p.renderer.flush(true)
+ }
+
+ _ = p.renderer.close()
+}
diff --git a/vendor/charm.land/bubbletea/v2/termcap.go b/vendor/charm.land/bubbletea/v2/termcap.go
new file mode 100644
index 000000000..c66d95ae5
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/termcap.go
@@ -0,0 +1,48 @@
+package tea
+
+// requestCapabilityMsg is an internal message that requests the terminal to
+// send its Termcap/Terminfo response.
+type requestCapabilityMsg string
+
+// RequestCapability is a command that requests the terminal to send its
+// Termcap/Terminfo response for the given capability.
+//
+// Bubble Tea recognizes the following capabilities and will use them to
+// upgrade the program's color profile:
+// - "RGB" Xterm direct color
+// - "Tc" True color support
+//
+// Note: that some terminal's like Apple's Terminal.app do not support this and
+// will send the wrong response to the terminal breaking the program's output.
+//
+// When the Bubble Tea advertises a non-TrueColor profile, you can use this
+// command to query the terminal for its color capabilities. Example:
+//
+// switch msg := msg.(type) {
+// case tea.ColorProfileMsg:
+// if msg.Profile != colorprofile.TrueColor {
+// return m, tea.Batch(
+// tea.RequestCapability("RGB"),
+// tea.RequestCapability("Tc"),
+// )
+// }
+// }
+func RequestCapability(s string) Cmd {
+ return func() Msg {
+ return requestCapabilityMsg(s)
+ }
+}
+
+// CapabilityMsg represents a Termcap/Terminfo response event. Termcap
+// responses are generated by the terminal in response to RequestTermcap
+// (XTGETTCAP) requests.
+//
+// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands
+type CapabilityMsg struct {
+ Content string
+}
+
+// String returns the capability content as a string.
+func (c CapabilityMsg) String() string {
+ return c.Content
+}
diff --git a/vendor/charm.land/bubbletea/v2/termios_bsd.go b/vendor/charm.land/bubbletea/v2/termios_bsd.go
new file mode 100644
index 000000000..cc716e585
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/termios_bsd.go
@@ -0,0 +1,13 @@
+//go:build dragonfly || freebsd
+// +build dragonfly freebsd
+
+package tea
+
+import (
+ "github.com/charmbracelet/x/term"
+ "golang.org/x/sys/unix"
+)
+
+func (p *Program) checkOptimizedMovements(s *term.State) {
+ p.useHardTabs = s.Oflag&unix.TABDLY == unix.TAB0
+}
diff --git a/vendor/charm.land/bubbletea/v2/termios_other.go b/vendor/charm.land/bubbletea/v2/termios_other.go
new file mode 100644
index 000000000..d4ede6d04
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/termios_other.go
@@ -0,0 +1,8 @@
+//go:build !windows && !darwin && !dragonfly && !freebsd && !linux && !solaris && !aix
+// +build !windows,!darwin,!dragonfly,!freebsd,!linux,!solaris,!aix
+
+package tea
+
+import "github.com/charmbracelet/x/term"
+
+func (*Program) checkOptimizedMovements(*term.State) {}
diff --git a/vendor/charm.land/bubbletea/v2/termios_unix.go b/vendor/charm.land/bubbletea/v2/termios_unix.go
new file mode 100644
index 000000000..3ee0e9948
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/termios_unix.go
@@ -0,0 +1,14 @@
+//go:build darwin || linux || solaris || aix
+// +build darwin linux solaris aix
+
+package tea
+
+import (
+ "github.com/charmbracelet/x/term"
+ "golang.org/x/sys/unix"
+)
+
+func (p *Program) checkOptimizedMovements(s *term.State) {
+ p.useHardTabs = s.Oflag&unix.TABDLY == unix.TAB0
+ p.useBackspace = s.Lflag&unix.BSDLY == unix.BS0
+}
diff --git a/vendor/charm.land/bubbletea/v2/termios_windows.go b/vendor/charm.land/bubbletea/v2/termios_windows.go
new file mode 100644
index 000000000..c743652c8
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/termios_windows.go
@@ -0,0 +1,11 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import "github.com/charmbracelet/x/term"
+
+func (p *Program) checkOptimizedMovements(*term.State) {
+ p.useHardTabs = true
+ p.useBackspace = true
+}
diff --git a/vendor/charm.land/bubbletea/v2/tty.go b/vendor/charm.land/bubbletea/v2/tty.go
new file mode 100644
index 000000000..12b86493b
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/tty.go
@@ -0,0 +1,136 @@
+package tea
+
+import (
+ "fmt"
+ "os"
+ "time"
+
+ uv "github.com/charmbracelet/ultraviolet"
+ "github.com/charmbracelet/x/term"
+)
+
+func (p *Program) suspend() {
+ if err := p.releaseTerminal(true); err != nil {
+ // If we can't release input, abort.
+ return
+ }
+
+ suspendProcess()
+
+ _ = p.RestoreTerminal()
+ go p.Send(ResumeMsg{})
+}
+
+func (p *Program) initTerminal() error {
+ if p.disableRenderer {
+ return nil
+ }
+ return p.initInput()
+}
+
+// restoreTerminalState restores the terminal to the state prior to running the
+// Bubble Tea program.
+func (p *Program) restoreTerminalState() error {
+ // Flush queued commands.
+ _ = p.flush()
+
+ return p.restoreInput()
+}
+
+// restoreInput restores the tty input to its original state.
+func (p *Program) restoreInput() error {
+ if p.ttyInput != nil && p.previousTtyInputState != nil {
+ if err := term.Restore(p.ttyInput.Fd(), p.previousTtyInputState); err != nil {
+ return fmt.Errorf("bubbletea: error restoring console: %w", err)
+ }
+ }
+ if p.ttyOutput != nil && p.previousOutputState != nil {
+ if err := term.Restore(p.ttyOutput.Fd(), p.previousOutputState); err != nil {
+ return fmt.Errorf("bubbletea: error restoring console: %w", err)
+ }
+ }
+ return nil
+}
+
+// initInputReader (re)commences reading inputs.
+func (p *Program) initInputReader(cancel bool) error {
+ if cancel && p.cancelReader != nil {
+ p.cancelReader.Cancel()
+ p.waitForReadLoop()
+ }
+
+ term := p.environ.Getenv("TERM")
+
+ // Initialize the input reader.
+ // This need to be done after the terminal has been initialized and set to
+ // raw mode.
+
+ var err error
+ p.cancelReader, err = uv.NewCancelReader(p.input)
+ if err != nil {
+ return fmt.Errorf("bubbletea: could not create cancelable reader: %w", err)
+ }
+
+ drv := uv.NewTerminalReader(p.cancelReader, term)
+ drv.SetLogger(p.logger)
+ p.inputScanner = drv
+ p.readLoopDone = make(chan struct{})
+
+ go p.readLoop()
+
+ return nil
+}
+
+func (p *Program) readLoop() {
+ defer close(p.readLoopDone)
+
+ if err := p.inputScanner.StreamEvents(p.ctx, p.msgs); err != nil {
+ select {
+ case <-p.ctx.Done():
+ return
+ case p.errs <- err:
+ }
+ }
+}
+
+// waitForReadLoop waits for the cancelReader to finish its read loop.
+func (p *Program) waitForReadLoop() {
+ select {
+ case <-p.readLoopDone:
+ case <-time.After(500 * time.Millisecond): //nolint:mnd
+ // The read loop hangs, which means the input
+ // cancelReader's cancel function has returned true even
+ // though it was not able to cancel the read.
+ }
+}
+
+// checkResize detects the current size of the output and informs the program
+// via a WindowSizeMsg.
+func (p *Program) checkResize() {
+ if p.ttyOutput == nil {
+ // can't query window size
+ return
+ }
+
+ w, h, err := term.GetSize(p.ttyOutput.Fd())
+ if err != nil {
+ select {
+ case <-p.ctx.Done():
+ case p.errs <- err:
+ }
+
+ return
+ }
+
+ p.width, p.height = w, h
+ p.Send(WindowSizeMsg{Width: w, Height: h})
+}
+
+// OpenTTY opens the running terminal's TTY for reading and writing.
+func OpenTTY() (*os.File, *os.File, error) {
+ in, out, err := uv.OpenTTY()
+ if err != nil {
+ return nil, nil, fmt.Errorf("bubbletea: could not open TTY: %w", err)
+ }
+ return in, out, nil
+}
diff --git a/vendor/charm.land/bubbletea/v2/tty_unix.go b/vendor/charm.land/bubbletea/v2/tty_unix.go
new file mode 100644
index 000000000..4981a560a
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/tty_unix.go
@@ -0,0 +1,47 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix zos
+
+package tea
+
+import (
+ "fmt"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/charmbracelet/x/term"
+)
+
+func (p *Program) initInput() (err error) {
+ // Check if input is a terminal
+ if f, ok := p.input.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyInput = f
+ p.previousTtyInputState, err = term.MakeRaw(p.ttyInput.Fd())
+ if err != nil {
+ return fmt.Errorf("error entering raw mode: %w", err)
+ }
+
+ // OPTIM: We can use hard tabs and backspaces to optimize cursor
+ // movements. This is based on termios settings support and whether
+ // they exist and enabled.
+ p.checkOptimizedMovements(p.previousTtyInputState)
+ }
+
+ if f, ok := p.output.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyOutput = f
+ }
+
+ return nil
+}
+
+const suspendSupported = true
+
+// Send SIGTSTP to the entire process group.
+func suspendProcess() {
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, syscall.SIGCONT)
+ defer signal.Stop(c)
+ _ = syscall.Kill(0, syscall.SIGTSTP)
+ // blocks until a CONT happens...
+ <-c
+}
diff --git a/vendor/charm.land/bubbletea/v2/tty_windows.go b/vendor/charm.land/bubbletea/v2/tty_windows.go
new file mode 100644
index 000000000..27b31182a
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/tty_windows.go
@@ -0,0 +1,64 @@
+//go:build windows
+// +build windows
+
+package tea
+
+import (
+ "fmt"
+
+ "github.com/charmbracelet/x/term"
+ "golang.org/x/sys/windows"
+)
+
+func (p *Program) initInput() (err error) {
+ // Save stdin state and enable VT input
+ // We also need to enable VT
+ // input here.
+ if f, ok := p.input.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyInput = f
+ p.previousTtyInputState, err = term.MakeRaw(p.ttyInput.Fd())
+ if err != nil {
+ return fmt.Errorf("error making terminal raw: %w", err)
+ }
+
+ // Enable VT input
+ var mode uint32
+ if err := windows.GetConsoleMode(windows.Handle(p.ttyInput.Fd()), &mode); err != nil {
+ return fmt.Errorf("error getting console mode: %w", err)
+ }
+
+ if err := windows.SetConsoleMode(windows.Handle(p.ttyInput.Fd()), mode|windows.ENABLE_VIRTUAL_TERMINAL_INPUT); err != nil {
+ return fmt.Errorf("error setting console mode: %w", err)
+ }
+ }
+
+ // Save output screen buffer state and enable VT processing.
+ if f, ok := p.output.(term.File); ok && term.IsTerminal(f.Fd()) {
+ p.ttyOutput = f
+ p.previousOutputState, err = term.GetState(f.Fd())
+ if err != nil {
+ return fmt.Errorf("error getting terminal state: %w", err)
+ }
+
+ var mode uint32
+ if err := windows.GetConsoleMode(windows.Handle(p.ttyOutput.Fd()), &mode); err != nil {
+ return fmt.Errorf("error getting console mode: %w", err)
+ }
+
+ if err := windows.SetConsoleMode(windows.Handle(p.ttyOutput.Fd()),
+ mode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING|
+ windows.DISABLE_NEWLINE_AUTO_RETURN); err != nil {
+ return fmt.Errorf("error setting console mode: %w", err)
+ }
+
+ //nolint:godox
+ // TODO: check if we can optimize cursor movements on Windows.
+ p.checkOptimizedMovements(p.previousOutputState)
+ }
+
+ return //nolint:nakedret
+}
+
+const suspendSupported = false
+
+func suspendProcess() {}
diff --git a/vendor/charm.land/bubbletea/v2/xterm.go b/vendor/charm.land/bubbletea/v2/xterm.go
new file mode 100644
index 000000000..0ffcd08fe
--- /dev/null
+++ b/vendor/charm.land/bubbletea/v2/xterm.go
@@ -0,0 +1,22 @@
+package tea
+
+// TerminalVersionMsg is a message that represents the terminal version.
+type TerminalVersionMsg struct {
+ Name string
+}
+
+// String returns the terminal name as a string.
+func (t TerminalVersionMsg) String() string {
+ return t.Name
+}
+
+// terminalVersion is an internal message that queries the terminal for its
+// version using XTVERSION.
+type terminalVersion struct{}
+
+// RequestTerminalVersion is a command that queries the terminal for its
+// version using XTVERSION. Note that some terminals may not support this
+// command.
+func RequestTerminalVersion() Msg {
+ return terminalVersion{}
+}
diff --git a/vendor/charm.land/lipgloss/v2/.editorconfig b/vendor/charm.land/lipgloss/v2/.editorconfig
new file mode 100644
index 000000000..5de2df8c5
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/.editorconfig
@@ -0,0 +1,18 @@
+# https://editorconfig.org/
+
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.go]
+indent_style = tab
+indent_size = 8
+
+[*.golden]
+insert_final_newline = false
+trim_trailing_whitespace = false
diff --git a/vendor/charm.land/lipgloss/v2/.gitattributes b/vendor/charm.land/lipgloss/v2/.gitattributes
new file mode 100644
index 000000000..d5273520a
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/.gitattributes
@@ -0,0 +1 @@
+*.golden linguist-generated=true -text
diff --git a/vendor/charm.land/lipgloss/v2/.gitignore b/vendor/charm.land/lipgloss/v2/.gitignore
new file mode 100644
index 000000000..3b478f575
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/.gitignore
@@ -0,0 +1,3 @@
+ssh_example_ed25519*
+/tmp
+**/.crush/**
diff --git a/vendor/charm.land/lipgloss/v2/.golangci.yml b/vendor/charm.land/lipgloss/v2/.golangci.yml
new file mode 100644
index 000000000..c90f03161
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/.golangci.yml
@@ -0,0 +1,47 @@
+version: "2"
+run:
+ tests: false
+linters:
+ enable:
+ - bodyclose
+ - exhaustive
+ - goconst
+ - godot
+ - gomoddirectives
+ - goprintffuncname
+ - gosec
+ - misspell
+ - nakedret
+ - nestif
+ - nilerr
+ - noctx
+ - nolintlint
+ - prealloc
+ - revive
+ - rowserrcheck
+ - sqlclosecheck
+ - tparallel
+ - unconvert
+ - unparam
+ - whitespace
+ - wrapcheck
+ exclusions:
+ rules:
+ - text: '(slog|log)\.\w+'
+ linters:
+ - noctx
+ generated: lax
+ presets:
+ - common-false-positives
+ settings:
+ exhaustive:
+ default-signifies-exhaustive: true
+issues:
+ max-issues-per-linter: 0
+ max-same-issues: 0
+formatters:
+ enable:
+ - gofumpt
+ - goimports
+ exclusions:
+ generated: lax
diff --git a/vendor/charm.land/lipgloss/v2/.goreleaser.yml b/vendor/charm.land/lipgloss/v2/.goreleaser.yml
new file mode 100644
index 000000000..c61970e07
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/.goreleaser.yml
@@ -0,0 +1,5 @@
+includes:
+ - from_url:
+ url: charmbracelet/meta/main/goreleaser-lib.yaml
+# yaml-language-server: $schema=https://goreleaser.com/static/schema-pro.json
+
diff --git a/vendor/charm.land/lipgloss/v2/LICENSE b/vendor/charm.land/lipgloss/v2/LICENSE
new file mode 100644
index 000000000..9f60dc1fc
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2026 Charmbracelet, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/charm.land/lipgloss/v2/README.md b/vendor/charm.land/lipgloss/v2/README.md
new file mode 100644
index 000000000..4fda64003
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/README.md
@@ -0,0 +1,996 @@
+# Lip Gloss
+
+
+
+ 
+ 
+ 
+
Style definitions for nice terminal layouts. Built with TUIs in mind.
+ + + +Lip Gloss takes an expressive, declarative approach to terminal rendering. +Users familiar with CSS will feel at home with Lip Gloss. + +```go +import "charm.land/lipgloss/v2" + +var style = lipgloss.NewStyle(). + Bold(true). + Foreground(lipgloss.Color("#FAFAFA")). + Background(lipgloss.Color("#7D56F4")). + PaddingTop(2). + PaddingLeft(4). + Width(22) + +lipgloss.Println(style.Render("Hello, kitty")) +``` + +## Installation + +```bash +go get charm.land/lipgloss/v2 +``` + +> [!TIP] +> +> Upgrading from v1? Check out the [upgrade guide](./UPGRADE_GUIDE_V2.md), or +> point your LLM at it and let it go to town. + +## Colors + +Lip Gloss supports the following color profiles: + +### ANSI 16 colors (4-bit) + +```go +lipgloss.Color("5") // magenta +lipgloss.Color("9") // red +lipgloss.Color("12") // light blue +``` + +### ANSI 256 Colors (8-bit) + +```go +lipgloss.Color("86") // aqua +lipgloss.Color("201") // hot pink +lipgloss.Color("202") // orange +``` + +### True Color (16,777,216 colors; 24-bit) + +```go +lipgloss.Color("#0000FF") // good ol' 100% blue +lipgloss.Color("#04B575") // a green +lipgloss.Color("#3C3C3C") // a dark gray +``` + +...as well as a 1-bit ASCII profile, which is black and white only. + +There are also named constants for the 16 standard ANSI colors: + +```go +lipgloss.Black +lipgloss.Red +lipgloss.Green +lipgloss.Yellow +lipgloss.Blue +lipgloss.Magenta +lipgloss.Cyan +lipgloss.White +lipgloss.BrightBlack +lipgloss.BrightRed +lipgloss.BrightGreen +lipgloss.BrightYellow +lipgloss.BrightBlue +lipgloss.BrightMagenta +lipgloss.BrightCyan +lipgloss.BrightWhite +``` + +### Automatically Downsampling Colors + +Some users don't have Truecolor terminals. Other times, output might not +support color at all (for example, in logs). Lip Gloss was designed to handle +this gracefully by automatically downsampling colors to the best available +profile. + +If you're using Lip Gloss with Bubble Tea, there’s nothing to do. If you're +using Lip Gloss standalone, just use `lipgloss.Println` or `lipgloss.Sprint` +(and their variants). + +For more, see [advanced color usage](#advanced-color-usage). + +### Color Utilities + +Lip Gloss ships with a handful of handy tools for working with colors: + +```go +c := lipgloss.Color("#EB4268") // Sriracha sauce color +dark := lipgloss.Darken(c, 0.5) // dark Sriracha sauce +light := lipgloss.Lighten(c, 0.35) // light Sriracha sauce +green := lipgloss.Complementary(c) // greenish Sriracha sauce +withAlpha := lipgloss.Alpha(c, 0.2) // watered down Sriracha sauce +``` + +### Advanced Color Tooling + +Lip Gloss also supports color blending, automatically choosing light or dark +variants of colors at runtime, and a lot more. For details, see [Advanced Color +Usage](#advanced-color-usage) and [the docs][docs]. + +## Inline Formatting + +Lip Gloss supports the usual ANSI text formatting options: + +```go +var style = lipgloss.NewStyle(). + Bold(true). + Italic(true). + Faint(true). + Blink(true). + Strikethrough(true). + Underline(true). + Reverse(true) +``` + +### Underline Styles + +Beyond simple on/off, underlines support multiple styles and custom colors: + +```go +s := lipgloss.NewStyle(). + UnderlineStyle(lipgloss.UnderlineCurly). + UnderlineColor(lipgloss.Color("#FF0000")) +``` + +Available styles: `UnderlineNone`, `UnderlineSingle`, `UnderlineDouble`, +`UnderlineCurly`, `UnderlineDotted`, `UnderlineDashed`. + +### Hyperlinks + +Styles can render clickable hyperlinks in supporting terminals: + +```go +s := lipgloss.NewStyle(). + Foreground(lipgloss.Color("#7B2FBE")). + Hyperlink("https://charm.land") + +lipgloss.Println(s.Render("Visit Charm")) +``` + +In unsupported terminals this will degrade gracefully and hyperlinks will +simply not render. + +## Block-Level Formatting + +Lip Gloss also supports rules for block-level formatting: + +```go +// Padding +var style = lipgloss.NewStyle(). + PaddingTop(2). + PaddingRight(4). + PaddingBottom(2). + PaddingLeft(4) + +// Margins +var style = lipgloss.NewStyle(). + MarginTop(2). + MarginRight(4). + MarginBottom(2). + MarginLeft(4) +``` + +There is also shorthand syntax for margins and padding, which follows the same +format as CSS: + +```go +// 2 cells on all sides +lipgloss.NewStyle().Padding(2) + +// 2 cells on the top and bottom, 4 cells on the left and right +lipgloss.NewStyle().Margin(2, 4) + +// 1 cell on the top, 4 cells on the sides, 2 cells on the bottom +lipgloss.NewStyle().Padding(1, 4, 2) + +// Clockwise, starting from the top: 2 cells on the top, 4 on the right, 3 on +// the bottom, and 1 on the left +lipgloss.NewStyle().Margin(2, 4, 3, 1) +``` + +You can also customize the characters used for padding and margin fill: + +```go +s := lipgloss.NewStyle(). + Padding(1, 2). + PaddingChar('·'). + Margin(1, 2). + MarginChar('░') +``` + +## Aligning Text + +You can align paragraphs of text to the left, right, or center. + +```go +var style = lipgloss.NewStyle(). + Width(24). + Align(lipgloss.Left). // align it left + Align(lipgloss.Right). // no wait, align it right + Align(lipgloss.Center) // just kidding, align it in the center +``` + +## Width and Height + +Setting a minimum width and height is simple and straightforward. + +```go +var style = lipgloss.NewStyle(). + SetString("What’s for lunch?"). + Width(24). + Height(32). + Foreground(lipgloss.Color("63")) +``` + +## Borders + +Adding borders is easy: + +```go +// Add a purple, rectangular border +var style = lipgloss.NewStyle(). + BorderStyle(lipgloss.NormalBorder()). + BorderForeground(lipgloss.Color("63")) + +// Set a rounded, yellow-on-purple border to the top and left +var anotherStyle = lipgloss.NewStyle(). + BorderStyle(lipgloss.RoundedBorder()). + BorderForeground(lipgloss.Color("228")). + BorderBackground(lipgloss.Color("63")). + BorderTop(true). + BorderLeft(true) + +// Make your own border +var myCuteBorder = lipgloss.Border{ + Top: "._.:*:", + Bottom: "._.:*:", + Left: "|*", + Right: "|*", + TopLeft: "*", + TopRight: "*", + BottomLeft: "*", + BottomRight: "*", +} +``` + +There are also shorthand functions for defining borders, which follow a similar +pattern to the margin and padding shorthand functions. + +```go +// Add a thick border to the top and bottom +lipgloss.NewStyle(). + Border(lipgloss.ThickBorder(), true, false) + +// Add a double border to the top and left sides. Rules are set clockwise +// from top. +lipgloss.NewStyle(). + Border(lipgloss.DoubleBorder(), true, false, false, true) +``` + +You can also pass multiple colors to a border for a gradient effect: + +```go +s := lipgloss.NewStyle(). + Border(lipgloss.RoundedBorder()). + BorderForegroundBlend(lipgloss.Color("#FF0000"), lipgloss.Color("#0000FF")) +``` + +For more on borders see [the docs](https://pkg.go.dev/charm.land/lipgloss/v2#Border). + +## Copying Styles + +Just use assignment: + +```go +style := lipgloss.NewStyle().Foreground(lipgloss.Color("219")) + +copiedStyle := style // this is a true copy + +wildStyle := style.Blink(true) // this is also true copy, with blink added +``` + +Since `Style` is a pure value type, assigning a style to another effectively +creates a new copy of the style without mutating the original. + +## Inheritance + +Styles can inherit rules from other styles. When inheriting, only unset rules +on the receiver are inherited. + +```go +var styleA = lipgloss.NewStyle(). + Foreground(lipgloss.Color("229")). + Background(lipgloss.Color("63")) + +// Only the background color will be inherited here, because the foreground +// color will have been already set: +var styleB = lipgloss.NewStyle(). + Foreground(lipgloss.Color("201")). + Inherit(styleA) +``` + +## Unsetting Rules + +All rules can be unset: + +```go +var style = lipgloss.NewStyle(). + Bold(true). // make it bold + UnsetBold(). // jk don't make it bold + Background(lipgloss.Color("227")). // yellow background + UnsetBackground() // never mind +``` + +When a rule is unset, it won’t be inherited or copied. + +## Enforcing Rules + +Sometimes, such as when developing a component, you want to make sure style +definitions respect their intended purpose in the UI. This is where `Inline` +and `MaxWidth`, and `MaxHeight` come in: + +```go +// Force rendering onto a single line, ignoring margins, padding, and borders. +someStyle.Inline(true).Render("yadda yadda") + +// Also limit rendering to five cells +someStyle.Inline(true).MaxWidth(5).Render("yadda yadda") + +// Limit rendering to a 5x5 cell block +someStyle.MaxWidth(5).MaxHeight(5).Render("yadda yadda") +``` + +## Tabs + +The tab character (`\t`) is rendered differently in different terminals (often +as 8 spaces, sometimes 4). Because of this inconsistency, Lip Gloss converts +tabs to 4 spaces at render time. This behavior can be changed on a per-style +basis, however: + +```go +style := lipgloss.NewStyle() // tabs will render as 4 spaces, the default +style = style.TabWidth(2) // render tabs as 2 spaces +style = style.TabWidth(0) // remove tabs entirely +style = style.TabWidth(lipgloss.NoTabConversion) // leave tabs intact +``` + +## Wrapping + +The `Wrap` function wraps text while preserving ANSI styles and hyperlinks +across line boundaries: + +```go +wrapped := lipgloss.Wrap(styledText, 40, " ") +``` + +## Rendering + +Generally, you just call the `Render(string...)` method on a `lipgloss.Style`: + +```go +style := lipgloss.NewStyle().Bold(true).SetString("Hello,") +lipgloss.Println(style.Render("kitty.")) // Hello, kitty. +lipgloss.Println(style.Render("puppy.")) // Hello, puppy. +``` + +But you could also use the Stringer interface: + +```go +var style = lipgloss.NewStyle().SetString("你好，猫咪。").Bold(true) +lipgloss.Println(style) // 你好，猫咪。 +``` + +## Utilities + +In addition to pure styling, Lip Gloss also ships with some utilities to help +assemble your layouts. + +### Compositing + +
+
+
+
+
+
+
+
+
+
+
+
+Charm热爱开源 • Charm loves open source
+
+[docs]: https://pkg.go.dev/charm.land/lipgloss/v2?tab=doc
diff --git a/vendor/charm.land/lipgloss/v2/Taskfile.yaml b/vendor/charm.land/lipgloss/v2/Taskfile.yaml
new file mode 100644
index 000000000..84fcf6c66
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/Taskfile.yaml
@@ -0,0 +1,24 @@
+# https://taskfile.dev
+
+version: "3"
+
+tasks:
+ lint:
+ desc: Run base linters
+ cmds:
+ - golangci-lint run
+
+ test:
+ desc: Run tests
+ cmds:
+ - go test ./... {{.CLI_ARGS}}
+
+ test:table:
+ desc: Run table tests
+ cmds:
+ - go test ./table {{.CLI_ARGS}}
+
+ test:tree:
+ desc: Run tree tests
+ cmds:
+ - go test ./tree {{.CLI_ARGS}}
diff --git a/vendor/charm.land/lipgloss/v2/UPGRADE_GUIDE_V2.md b/vendor/charm.land/lipgloss/v2/UPGRADE_GUIDE_V2.md
new file mode 100644
index 000000000..8f123f19d
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/UPGRADE_GUIDE_V2.md
@@ -0,0 +1,504 @@
+# Lip Gloss v2 Upgrade Guide
+
+This guide covers migrating from Lip Gloss v1 (`github.com/charmbracelet/lipgloss`)
+to Lip Gloss v2 (`charm.land/lipgloss/v2`). It is written for both humans and
+LLMs performing automated migrations.
+
+---
+
+## Table of Contents
+
+1. [Quick Start](#quick-start)
+2. [Module Path](#module-path)
+3. [Color System](#color-system)
+4. [Renderer Removal](#renderer-removal)
+5. [Printing and Color Downsampling](#printing-and-color-downsampling)
+6. [Background Detection and Adaptive Colors](#background-detection-and-adaptive-colors)
+7. [Whitespace Options](#whitespace-options)
+8. [Underline](#underline)
+9. [Style API Changes](#style-api-changes)
+10. [Tree Subpackage](#tree-subpackage)
+11. [Removed APIs](#removed-apis)
+12. [Quick Reference Table](#quick-reference-table)
+
+---
+
+## Quick Start
+
+For the fastest possible upgrade, do these two things:
+
+### 1. Use the `compat` package for adaptive/complete colors
+
+```go
+import "charm.land/lipgloss/v2/compat"
+
+// v1
+color := lipgloss.AdaptiveColor{Light: "#f1f1f1", Dark: "#cccccc"}
+
+// v2
+color := compat.AdaptiveColor{Light: lipgloss.Color("#f1f1f1"), Dark: lipgloss.Color("#cccccc")}
+```
+
+The `compat` package reads `stdin`/`stdout` globally, just like v1. To
+customize:
+
+```go
+import (
+ "charm.land/lipgloss/v2/compat"
+ "github.com/charmbracelet/colorprofile"
+)
+
+func init() {
+ compat.HasDarkBackground = lipgloss.HasDarkBackground(os.Stdin, os.Stderr)
+ compat.Profile = colorprofile.Detect(os.Stderr, os.Environ())
+}
+```
+
+### 2. Use Lip Gloss writers for output
+
+```go
+// v1
+fmt.Println(s)
+
+// v2
+lipgloss.Println(s)
+```
+
+This ensures colors are automatically downsampled. If you're using Bubble Tea
+v2, this step is unnecessary — Bubble Tea handles it for you.
+
+**That's the quick path.** Read on for the full migration details.
+
+---
+
+## Module Path
+
+The import path has changed.
+
+```go
+// v1
+import "github.com/charmbracelet/lipgloss"
+
+// v2
+import "charm.land/lipgloss/v2"
+```
+
+**Install:**
+
+```bash
+go get charm.land/lipgloss/v2
+```
+
+All subpackages follow the same pattern:
+
+```go
+// v1
+import "github.com/charmbracelet/lipgloss/table"
+import "github.com/charmbracelet/lipgloss/tree"
+import "github.com/charmbracelet/lipgloss/list"
+
+// v2
+import "charm.land/lipgloss/v2/table"
+import "charm.land/lipgloss/v2/tree"
+import "charm.land/lipgloss/v2/list"
+```
+
+**Search-and-replace pattern:**
+
+```
+github.com/charmbracelet/lipgloss → charm.land/lipgloss/v2
+```
+
+---
+
+## Color System
+
+This is the most significant API change.
+
+### `Color` is now a function, not a type
+
+```go
+// v1 — Color is a string type
+var c lipgloss.Color = "21"
+var c lipgloss.Color = "#ff00ff"
+
+// v2 — Color is a function returning color.Color
+var c color.Color = lipgloss.Color("21")
+var c color.Color = lipgloss.Color("#ff00ff")
+```
+
+The return type is `image/color.Color` (from the standard library).
+
+### `TerminalColor` interface is removed
+
+All methods that accepted `lipgloss.TerminalColor` now accept
+`image/color.Color`:
+
+```go
+// v1
+func (s Style) Foreground(c TerminalColor) Style
+func (s Style) Background(c TerminalColor) Style
+func (s Style) BorderForeground(c ...TerminalColor) Style
+
+// v2
+func (s Style) Foreground(c color.Color) Style
+func (s Style) Background(c color.Color) Style
+func (s Style) BorderForeground(c ...color.Color) Style
+```
+
+**Migration:** Replace every `lipgloss.TerminalColor` with `color.Color` and
+add `import "image/color"`.
+
+### `ANSIColor` is now an alias
+
+```go
+// v1 — custom uint type
+type ANSIColor uint
+
+// v2 — alias for ansi.IndexedColor
+type ANSIColor = ansi.IndexedColor
+```
+
+v2 also exports named constants for the 16 basic ANSI colors:
+
+```go
+lipgloss.Black, lipgloss.Red, lipgloss.Green, lipgloss.Yellow,
+lipgloss.Blue, lipgloss.Magenta, lipgloss.Cyan, lipgloss.White,
+lipgloss.BrightBlack, lipgloss.BrightRed, lipgloss.BrightGreen,
+lipgloss.BrightYellow, lipgloss.BrightBlue, lipgloss.BrightMagenta,
+lipgloss.BrightCyan, lipgloss.BrightWhite
+```
+
+### `AdaptiveColor`, `CompleteColor`, `CompleteAdaptiveColor`
+
+These types have been moved out of the root package. Use the `compat` package
+for a drop-in replacement, or use the new `LightDark` and `Complete` helpers
+for explicit control:
+
+```go
+// v1
+color := lipgloss.AdaptiveColor{Light: "#0000ff", Dark: "#000099"}
+
+// v2 — using compat (quick path)
+color := compat.AdaptiveColor{
+ Light: lipgloss.Color("#0000ff"),
+ Dark: lipgloss.Color("#000099"),
+}
+
+// v2 — using LightDark (recommended)
+hasDark := lipgloss.HasDarkBackground(os.Stdin, os.Stdout)
+lightDark := lipgloss.LightDark(hasDark)
+color := lightDark(lipgloss.Color("#0000ff"), lipgloss.Color("#000099"))
+```
+
+```go
+// v1
+color := lipgloss.CompleteColor{TrueColor: "#ff00ff", ANSI256: "200", ANSI: "5"}
+
+// v2 — using compat
+color := compat.CompleteColor{
+ TrueColor: lipgloss.Color("#ff00ff"),
+ ANSI256: lipgloss.Color("200"),
+ ANSI: lipgloss.Color("5"),
+}
+
+// v2 — using Complete (recommended)
+profile := colorprofile.Detect(os.Stdout, os.Environ())
+complete := lipgloss.Complete(profile)
+color := complete(lipgloss.Color("5"), lipgloss.Color("200"), lipgloss.Color("#ff00ff"))
+```
+
+Note that `compat.AdaptiveColor` and friends take `color.Color` values for
+their fields, not strings.
+
+---
+
+## Renderer Removal
+
+The `Renderer` type and all associated functions are removed. In v1, every
+`Style` carried a `*Renderer` pointer and the package maintained a global
+default renderer.
+
+```go
+// v1 — these no longer exist
+lipgloss.DefaultRenderer()
+lipgloss.SetDefaultRenderer(r)
+lipgloss.NewRenderer(w, opts...)
+lipgloss.ColorProfile()
+lipgloss.SetColorProfile(p)
+renderer.NewStyle()
+```
+
+**In v2, `Style` is a plain value type.** There is no renderer. Color
+downsampling is handled at the output layer (see next section).
+
+**Migration:**
+
+- Replace `lipgloss.DefaultRenderer().NewStyle()` with `lipgloss.NewStyle()`.
+- Replace `renderer.NewStyle()` with `lipgloss.NewStyle()`.
+- Remove any `*Renderer` fields from your types.
+- Remove calls to `SetColorProfile` — use `colorprofile.Detect` at the output
+ layer instead.
+
+---
+
+## Printing and Color Downsampling
+
+In v1, color downsampling happened inside `Style.Render()` via the renderer. In
+v2, `Render()` always emits full-fidelity ANSI. Downsampling happens when you
+print.
+
+### Standalone Usage
+
+Use the Lip Gloss writer functions:
+
+```go
+s := someStyle.Render("Hello!")
+
+// Print to stdout with automatic downsampling
+lipgloss.Println(s)
+
+// Print to stderr
+lipgloss.Fprintln(os.Stderr, s)
+
+// Render to a string (downsampled for stdout's profile)
+str := lipgloss.Sprint(s)
+```
+
+The default writer targets `stdout`. To customize:
+
+```go
+lipgloss.Writer = colorprofile.NewWriter(os.Stderr, os.Environ())
+```
+
+### With Bubble Tea
+
+No changes needed. Bubble Tea v2 handles downsampling internally.
+
+---
+
+## Background Detection and Adaptive Colors
+
+### Standalone
+
+v1 detected the background color automatically via the global renderer. v2
+requires explicit queries:
+
+```go
+// v1
+hasDark := lipgloss.HasDarkBackground()
+
+// v2 — specify the input and output
+hasDark := lipgloss.HasDarkBackground(os.Stdin, os.Stdout)
+```
+
+Then use `LightDark` to pick colors:
+
+```go
+lightDark := lipgloss.LightDark(hasDark)
+fg := lightDark(lipgloss.Color("#333333"), lipgloss.Color("#f1f1f1"))
+
+s := lipgloss.NewStyle().Foreground(fg)
+```
+
+### With Bubble Tea
+
+Request the background color in `Init` and listen for the response:
+
+```go
+func (m model) Init() tea.Cmd {
+ return tea.RequestBackgroundColor
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+ switch msg := msg.(type) {
+ case tea.BackgroundColorMsg:
+ m.styles = newStyles(msg.IsDark())
+ }
+ // ...
+}
+
+func newStyles(bgIsDark bool) styles {
+ lightDark := lipgloss.LightDark(bgIsDark)
+ return styles{
+ title: lipgloss.NewStyle().Foreground(lightDark(
+ lipgloss.Color("#333333"),
+ lipgloss.Color("#f1f1f1"),
+ )),
+ }
+}
+```
+
+---
+
+## Whitespace Options
+
+The separate foreground/background whitespace options have been replaced by a
+single style option:
+
+```go
+// v1
+lipgloss.Place(width, height, hPos, vPos, str,
+ lipgloss.WithWhitespaceForeground(lipgloss.Color("#333")),
+ lipgloss.WithWhitespaceBackground(lipgloss.Color("#000")),
+)
+
+// v2
+lipgloss.Place(width, height, hPos, vPos, str,
+ lipgloss.WithWhitespaceStyle(lipgloss.NewStyle().
+ Foreground(lipgloss.Color("#333")).
+ Background(lipgloss.Color("#000")),
+ ),
+)
+```
+
+---
+
+## Underline
+
+`Underline(bool)` still works for basic on/off. v2 adds fine-grained control:
+
+```go
+// v1
+s := lipgloss.NewStyle().Underline(true)
+
+// v2 — still works
+s := lipgloss.NewStyle().Underline(true)
+
+// v2 — new: specific styles
+s := lipgloss.NewStyle().UnderlineStyle(lipgloss.UnderlineCurly)
+
+// v2 — new: colored underlines
+s := lipgloss.NewStyle().
+ UnderlineStyle(lipgloss.UnderlineSingle).
+ UnderlineColor(lipgloss.Color("#FF0000"))
+```
+
+Internally, `Underline(true)` is equivalent to `UnderlineStyle(UnderlineSingle)`
+and `Underline(false)` is equivalent to `UnderlineStyle(UnderlineNone)`.
+
+---
+
+## Style API Changes
+
+### `NewStyle()` is no longer tied to a Renderer
+
+```go
+// v1
+s := lipgloss.NewStyle() // uses global renderer
+s := renderer.NewStyle() // uses specific renderer
+
+// v2
+s := lipgloss.NewStyle() // pure value, no renderer
+```
+
+### Color getters return `color.Color`
+
+```go
+// v1
+fg := s.GetForeground() // returns TerminalColor
+
+// v2
+fg := s.GetForeground() // returns color.Color
+```
+
+### New style methods
+
+| Method | Description |
+|---|---|
+| `UnderlineStyle(Underline)` | Set underline style (single, double, curly, etc.) |
+| `UnderlineColor(color.Color)` | Set underline color |
+| `PaddingChar(rune)` | Set the character used for padding fill |
+| `MarginChar(rune)` | Set the character used for margin fill |
+| `Hyperlink(link, params...)` | Set a clickable hyperlink |
+| `BorderForegroundBlend(...color.Color)` | Apply gradient colors to borders |
+| `BorderForegroundBlendOffset(int)` | Set the offset for border gradient |
+
+Each has a corresponding `Get*`, `Unset*`, and where applicable `Get*`
+accessor.
+
+---
+
+## Tree Subpackage
+
+The import path changes and there are new styling options:
+
+```go
+// v1
+import "github.com/charmbracelet/lipgloss/tree"
+
+// v2
+import "charm.land/lipgloss/v2/tree"
+```
+
+New methods:
+
+- `IndenterStyle(lipgloss.Style)` — set a static style for tree indentation.
+- `IndenterStyleFunc(func(Children, int) lipgloss.Style)` — conditionally style
+ indentation.
+- `Width(int)` — set tree width for padding.
+
+---
+
+## Removed APIs
+
+The following types and functions no longer exist in v2. This table shows each
+removed symbol and its replacement.
+
+| v1 Symbol | v2 Replacement |
+|---|---|
+| `type Renderer` | Removed entirely |
+| `DefaultRenderer()` | Not needed |
+| `SetDefaultRenderer(r)` | Not needed |
+| `NewRenderer(w, opts...)` | Not needed |
+| `ColorProfile()` | `colorprofile.Detect(w, env)` |
+| `SetColorProfile(p)` | Set `lipgloss.Writer.Profile` |
+| `HasDarkBackground()` (no args) | `lipgloss.HasDarkBackground(in, out)` |
+| `SetHasDarkBackground(b)` | Not needed — pass bool to `LightDark` |
+| `type TerminalColor` | `image/color.Color` |
+| `type Color string` | `func Color(string) color.Color` |
+| `type ANSIColor uint` | `type ANSIColor = ansi.IndexedColor` |
+| `type AdaptiveColor` | `compat.AdaptiveColor` or `LightDark` |
+| `type CompleteColor` | `compat.CompleteColor` or `Complete` |
+| `type CompleteAdaptiveColor` | `compat.CompleteAdaptiveColor` |
+| `WithWhitespaceForeground(c)` | `WithWhitespaceStyle(s)` |
+| `WithWhitespaceBackground(c)` | `WithWhitespaceStyle(s)` |
+| `renderer.NewStyle()` | `lipgloss.NewStyle()` |
+
+---
+
+## Quick Reference Table
+
+A side-by-side summary for common patterns:
+
+| Task | v1 | v2 |
+|---|---|---|
+| Import | `"github.com/charmbracelet/lipgloss"` | `"charm.land/lipgloss/v2"` |
+| Create style | `lipgloss.NewStyle()` | `lipgloss.NewStyle()` |
+| Hex color | `lipgloss.Color("#ff00ff")` | `lipgloss.Color("#ff00ff")` |
+| ANSI color | `lipgloss.Color("5")` | `lipgloss.Color("5")` or `lipgloss.Magenta` |
+| Adaptive color | `lipgloss.AdaptiveColor{Light: "#fff", Dark: "#000"}` | `compat.AdaptiveColor{Light: lipgloss.Color("#fff"), Dark: lipgloss.Color("#000")}` |
+| Set foreground | `s.Foreground(lipgloss.Color("5"))` | `s.Foreground(lipgloss.Color("5"))` |
+| Print with downsampling | `fmt.Println(s.Render("hi"))` | `lipgloss.Println(s.Render("hi"))` |
+| Detect dark bg | `lipgloss.HasDarkBackground()` | `lipgloss.HasDarkBackground(os.Stdin, os.Stdout)` |
+| Light/dark color | `lipgloss.AdaptiveColor{...}` | `lipgloss.LightDark(isDark)(light, dark)` |
+| Whitespace styling | `WithWhitespaceForeground(c)` | `WithWhitespaceStyle(lipgloss.NewStyle().Foreground(c))` |
+| Underline | `s.Underline(true)` | `s.Underline(true)` or `s.UnderlineStyle(lipgloss.UnderlineCurly)` |
+
+---
+
+## Feedback
+
+Questions, issues, or feedback:
+
+- [Discord](https://charm.land/discord)
+- [Matrix](https://charm.land/matrix)
+- [Email](mailto:vt100@charm.land)
+
+---
+
+Part of [Charm](https://charm.land).
+
+
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
diff --git a/vendor/charm.land/lipgloss/v2/align.go b/vendor/charm.land/lipgloss/v2/align.go
new file mode 100644
index 000000000..d196213b7
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/align.go
@@ -0,0 +1,82 @@
+package lipgloss
+
+import (
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Perform text alignment. If the string is multi-lined, we also make all lines
+// the same width by padding them with spaces. If a style is passed, use that
+// to style the spaces added.
+func alignTextHorizontal(str string, pos Position, width int, style *ansi.Style) string {
+ lines, widestLine := getLines(str)
+ var b strings.Builder
+
+ for i, l := range lines {
+ lineWidth := ansi.StringWidth(l)
+
+ shortAmount := widestLine - lineWidth // difference from the widest line
+ shortAmount += max(0, width-(shortAmount+lineWidth)) // difference from the total width, if set
+
+ if shortAmount > 0 {
+ switch pos {
+ case Right:
+ s := strings.Repeat(" ", shortAmount)
+ if style != nil {
+ s = style.Styled(s)
+ }
+ l = s + l
+ case Center:
+ // Note: remainder goes on the right.
+ left := shortAmount / 2 //nolint:mnd
+ right := left + shortAmount%2 //nolint:mnd
+
+ leftSpaces := strings.Repeat(" ", left)
+ rightSpaces := strings.Repeat(" ", right)
+
+ if style != nil {
+ leftSpaces = style.Styled(leftSpaces)
+ rightSpaces = style.Styled(rightSpaces)
+ }
+ l = leftSpaces + l + rightSpaces
+ default: // Left
+ s := strings.Repeat(" ", shortAmount)
+ if style != nil {
+ s = style.Styled(s)
+ }
+ l += s
+ }
+ }
+
+ b.WriteString(l)
+ if i < len(lines)-1 {
+ b.WriteRune('\n')
+ }
+ }
+
+ return b.String()
+}
+
+func alignTextVertical(str string, pos Position, height int, _ *ansi.Style) string {
+ strHeight := strings.Count(str, "\n") + 1
+ if height < strHeight {
+ return str
+ }
+
+ switch pos {
+ case Top:
+ return str + strings.Repeat("\n", height-strHeight)
+ case Center:
+ topPadding, bottomPadding := (height-strHeight)/2, (height-strHeight)/2 //nolint:mnd
+ if strHeight+topPadding+bottomPadding > height {
+ topPadding--
+ } else if strHeight+topPadding+bottomPadding < height {
+ bottomPadding++
+ }
+ return strings.Repeat("\n", topPadding) + str + strings.Repeat("\n", bottomPadding)
+ case Bottom:
+ return strings.Repeat("\n", height-strHeight) + str
+ }
+ return str
+}
diff --git a/vendor/charm.land/lipgloss/v2/ansi_unix.go b/vendor/charm.land/lipgloss/v2/ansi_unix.go
new file mode 100644
index 000000000..b4fca7d19
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/ansi_unix.go
@@ -0,0 +1,8 @@
+//go:build !windows
+
+package lipgloss
+
+import "os"
+
+// EnableLegacyWindowsANSI is only needed on Windows.
+func EnableLegacyWindowsANSI(*os.File) {}
diff --git a/vendor/charm.land/lipgloss/v2/ansi_windows.go b/vendor/charm.land/lipgloss/v2/ansi_windows.go
new file mode 100644
index 000000000..8a1ef00eb
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/ansi_windows.go
@@ -0,0 +1,30 @@
+//go:build windows
+
+package lipgloss
+
+import (
+ "os"
+
+ "golang.org/x/sys/windows"
+)
+
+// EnableLegacyWindowsANSI enables support for ANSI color sequences in the
+// Windows default console (cmd.exe and the PowerShell application). Note that
+// this only works with Windows 10 and greater. Also note that Windows Terminal
+// supports colors by default.
+func EnableLegacyWindowsANSI(f *os.File) {
+ var mode uint32
+ handle := windows.Handle(f.Fd())
+ err := windows.GetConsoleMode(handle, &mode)
+ if err != nil {
+ return
+ }
+
+ // See https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences
+ if mode&windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING != windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING {
+ vtpmode := mode | windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING
+ if err := windows.SetConsoleMode(handle, vtpmode); err != nil {
+ return
+ }
+ }
+}
diff --git a/vendor/charm.land/lipgloss/v2/blending.go b/vendor/charm.land/lipgloss/v2/blending.go
new file mode 100644
index 000000000..82830f3e4
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/blending.go
@@ -0,0 +1,196 @@
+package lipgloss
+
+import (
+ "image/color"
+ "math"
+ "slices"
+
+ "github.com/lucasb-eyer/go-colorful"
+)
+
+// Blend1D blends a series of colors together in one linear dimension using multiple
+// stops, into the provided number of steps. Uses the "CIE L*, a*, b*" (CIELAB) color-space.
+//
+// Note that if any of the provided colors are completely transparent, we will
+// assume that the alpha value was lost in conversion from RGB -> RGBA, and we
+// will set the alpha to opaque, as it's not possible to blend something completely
+// transparent.
+func Blend1D(steps int, stops ...color.Color) []color.Color {
+ if steps < 0 {
+ steps = 0
+ }
+
+ if steps <= len(stops) {
+ return stops[:steps]
+ }
+
+ // Ensure they didn't provide any nil colors.
+ stops = slices.DeleteFunc(stops, func(c color.Color) bool {
+ return c == nil
+ })
+
+ if len(stops) == 0 {
+ return nil // We can't safely fallback.
+ }
+
+ // If they only provided one valid color (or some nil colors), we will just return
+ // an array of that color, for the amount of steps they requested.
+ if len(stops) == 1 {
+ singleColor := stops[0]
+ result := make([]color.Color, steps)
+ for i := range result {
+ result[i] = singleColor
+ }
+ return result
+ }
+
+ blended := make([]color.Color, steps)
+
+ // Convert stops to colorful.Color once
+ cstops := make([]colorful.Color, len(stops))
+ for i, k := range stops {
+ cstops[i], _ = colorful.MakeColor(ensureNotTransparent(k))
+ }
+
+ numSegments := len(cstops) - 1
+ defaultSize := steps / numSegments
+ remainingSteps := steps % numSegments
+
+ resultIndex := 0
+ for i := range numSegments {
+ from := cstops[i]
+ to := cstops[i+1]
+
+ // Calculate segment size.
+ segmentSize := defaultSize
+ if i < remainingSteps {
+ segmentSize++
+ }
+
+ divisor := float64(segmentSize - 1)
+
+ // Generate colors for this segment.
+ for j := 0; j < segmentSize; j++ {
+ var blendingFactor float64
+ if segmentSize > 1 {
+ blendingFactor = float64(j) / divisor
+ }
+ blended[resultIndex] = from.BlendLab(to, blendingFactor).Clamped()
+ resultIndex++
+ }
+ }
+
+ return blended
+}
+
+// Blend2D blends a series of colors together in two linear dimensions using
+// multiple stops, into the provided width/height. Uses the "CIE L*, a*, b*" (CIELAB)
+// color-space. The angle parameter controls the rotation of the gradient (0-360°),
+// where 0° is left-to-right, 45° is bottom-left to top-right (diagonal). The function
+// returns colors in a 1D row-major order ([row1, row2, row3, ...]).
+//
+// Example of how to iterate over the result:
+//
+// gradient := colors.Blend2D(width, height, 180, color1, color2, color3, ...)
+// gradientContent := strings.Builder{}
+// for y := range height {
+// for x := range width {
+// index := y*width + x
+// gradientContent.WriteString(
+// lipgloss.NewStyle().
+// Background(gradient[index]).
+// Render(" "),
+// )
+// }
+// if y < height-1 { // End of row.
+// gradientContent.WriteString("\n")
+// }
+// }
+//
+// Note that if any of the provided colors are completely transparent, we will
+// assume that the alpha value was lost in conversion from RGB -> RGBA, and we
+// will set the alpha to opaque, as it's not possible to blend something completely
+// transparent.
+func Blend2D(width, height int, angle float64, stops ...color.Color) []color.Color {
+ if width < 1 {
+ width = 1
+ }
+ if height < 1 {
+ height = 1
+ }
+
+ // Normalize angle to 0-360.
+ angle = math.Mod(angle, 360)
+ if angle < 0 {
+ angle += 360
+ }
+
+ // Ensure they didn't provide any nil colors.
+ stops = slices.DeleteFunc(stops, func(c color.Color) bool {
+ return c == nil
+ })
+
+ if len(stops) == 0 {
+ return nil // We can't safely fallback.
+ }
+
+ // If they only provided one valid color (or some nil colors), we will just return
+ // an array of that color, for the amount of pixels they requested.
+ if len(stops) == 1 {
+ singleColor := stops[0]
+ result := make([]color.Color, width*height)
+ for i := range result {
+ result[i] = singleColor
+ }
+ return result
+ }
+
+ // For 2D blending, we'll create a gradient along the diagonal and then sample
+ // from it based on the angle. We'll use the maximum dimension to ensure we have
+ // enough resolution for the gradient.
+ diagonalGradient := Blend1D(max(width, height), stops...)
+
+ result := make([]color.Color, width*height)
+
+ // Calculate center point for rotation.
+ centerX := float64(width-1) / 2.0
+ centerY := float64(height-1) / 2.0
+
+ angleRad := angle * math.Pi / 180.0 // -> radians.
+
+ // Pre-calculate sin and cos.
+ cosAngle := math.Cos(angleRad)
+ sinAngle := math.Sin(angleRad)
+
+ // Calculate diagonal length for proper gradient mapping.
+ diagonalLength := math.Sqrt(float64(width*width + height*height))
+
+ // Pre-calculate gradient length for index calculation.
+ gradientLen := float64(len(diagonalGradient) - 1)
+
+ for y := range height {
+ // Calculate the distance from center along the gradient direction.
+ dy := float64(y) - centerY
+
+ for x := 0; x < width; x++ {
+ // Calculate the distance from center along the gradient direction.
+ dx := float64(x) - centerX
+
+ rotX := dx*cosAngle - dy*sinAngle // Rotate the point by the angle.
+
+ // Map the rotated position to the gradient. Normalize to 0-1 range based on
+ // the diagonal length.
+ gradientPos := clamp((rotX+diagonalLength/2.0)/diagonalLength, 0, 1)
+
+ // Calculate the index in the gradient.
+ gradientIndex := int(gradientPos * gradientLen)
+ if gradientIndex >= len(diagonalGradient) {
+ gradientIndex = len(diagonalGradient) - 1
+ }
+
+ result[y*width+x] = diagonalGradient[gradientIndex] // -> row-major order.
+ }
+ }
+
+ return result
+}
diff --git a/vendor/charm.land/lipgloss/v2/borders.go b/vendor/charm.land/lipgloss/v2/borders.go
new file mode 100644
index 000000000..7f12360f6
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/borders.go
@@ -0,0 +1,587 @@
+package lipgloss
+
+import (
+ "image/color"
+ "slices"
+ "strings"
+ "unicode/utf8"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/clipperhouse/displaywidth"
+ "github.com/rivo/uniseg"
+)
+
+// Border contains a series of values which comprise the various parts of a
+// border.
+type Border struct {
+ Top string
+ Bottom string
+ Left string
+ Right string
+ TopLeft string
+ TopRight string
+ BottomLeft string
+ BottomRight string
+ MiddleLeft string
+ MiddleRight string
+ Middle string
+ MiddleTop string
+ MiddleBottom string
+}
+
+// GetTopSize returns the width of the top border. If borders contain runes of
+// varying widths, the widest rune is returned. If no border exists on the top
+// edge, 0 is returned.
+func (b Border) GetTopSize() int {
+ return getBorderEdgeWidth(b.TopLeft, b.Top, b.TopRight)
+}
+
+// GetRightSize returns the width of the right border. If borders contain
+// runes of varying widths, the widest rune is returned. If no border exists on
+// the right edge, 0 is returned.
+func (b Border) GetRightSize() int {
+ return getBorderEdgeWidth(b.TopRight, b.Right, b.BottomRight)
+}
+
+// GetBottomSize returns the width of the bottom border. If borders contain
+// runes of varying widths, the widest rune is returned. If no border exists on
+// the bottom edge, 0 is returned.
+func (b Border) GetBottomSize() int {
+ return getBorderEdgeWidth(b.BottomLeft, b.Bottom, b.BottomRight)
+}
+
+// GetLeftSize returns the width of the left border. If borders contain runes
+// of varying widths, the widest rune is returned. If no border exists on the
+// left edge, 0 is returned.
+func (b Border) GetLeftSize() int {
+ return getBorderEdgeWidth(b.TopLeft, b.Left, b.BottomLeft)
+}
+
+func getBorderEdgeWidth(borderParts ...string) (maxWidth int) {
+ for _, piece := range borderParts {
+ maxWidth = max(maxWidth, maxRuneWidth(piece))
+ }
+ return maxWidth
+}
+
+var (
+ noBorder = Border{}
+
+ normalBorder = Border{
+ Top: "─",
+ Bottom: "─",
+ Left: "│",
+ Right: "│",
+ TopLeft: "┌",
+ TopRight: "┐",
+ BottomLeft: "└",
+ BottomRight: "┘",
+ MiddleLeft: "├",
+ MiddleRight: "┤",
+ Middle: "┼",
+ MiddleTop: "┬",
+ MiddleBottom: "┴",
+ }
+
+ roundedBorder = Border{
+ Top: "─",
+ Bottom: "─",
+ Left: "│",
+ Right: "│",
+ TopLeft: "╭",
+ TopRight: "╮",
+ BottomLeft: "╰",
+ BottomRight: "╯",
+ MiddleLeft: "├",
+ MiddleRight: "┤",
+ Middle: "┼",
+ MiddleTop: "┬",
+ MiddleBottom: "┴",
+ }
+
+ blockBorder = Border{
+ Top: "█",
+ Bottom: "█",
+ Left: "█",
+ Right: "█",
+ TopLeft: "█",
+ TopRight: "█",
+ BottomLeft: "█",
+ BottomRight: "█",
+ MiddleLeft: "█",
+ MiddleRight: "█",
+ Middle: "█",
+ MiddleTop: "█",
+ MiddleBottom: "█",
+ }
+
+ outerHalfBlockBorder = Border{
+ Top: "▀",
+ Bottom: "▄",
+ Left: "▌",
+ Right: "▐",
+ TopLeft: "▛",
+ TopRight: "▜",
+ BottomLeft: "▙",
+ BottomRight: "▟",
+ }
+
+ innerHalfBlockBorder = Border{
+ Top: "▄",
+ Bottom: "▀",
+ Left: "▐",
+ Right: "▌",
+ TopLeft: "▗",
+ TopRight: "▖",
+ BottomLeft: "▝",
+ BottomRight: "▘",
+ }
+
+ thickBorder = Border{
+ Top: "━",
+ Bottom: "━",
+ Left: "┃",
+ Right: "┃",
+ TopLeft: "┏",
+ TopRight: "┓",
+ BottomLeft: "┗",
+ BottomRight: "┛",
+ MiddleLeft: "┣",
+ MiddleRight: "┫",
+ Middle: "╋",
+ MiddleTop: "┳",
+ MiddleBottom: "┻",
+ }
+
+ doubleBorder = Border{
+ Top: "═",
+ Bottom: "═",
+ Left: "║",
+ Right: "║",
+ TopLeft: "╔",
+ TopRight: "╗",
+ BottomLeft: "╚",
+ BottomRight: "╝",
+ MiddleLeft: "╠",
+ MiddleRight: "╣",
+ Middle: "╬",
+ MiddleTop: "╦",
+ MiddleBottom: "╩",
+ }
+
+ hiddenBorder = Border{
+ Top: " ",
+ Bottom: " ",
+ Left: " ",
+ Right: " ",
+ TopLeft: " ",
+ TopRight: " ",
+ BottomLeft: " ",
+ BottomRight: " ",
+ MiddleLeft: " ",
+ MiddleRight: " ",
+ Middle: " ",
+ MiddleTop: " ",
+ MiddleBottom: " ",
+ }
+
+ markdownBorder = Border{
+ Top: "-",
+ Bottom: "-",
+ Left: "|",
+ Right: "|",
+ TopLeft: "|",
+ TopRight: "|",
+ BottomLeft: "|",
+ BottomRight: "|",
+ MiddleLeft: "|",
+ MiddleRight: "|",
+ Middle: "|",
+ MiddleTop: "|",
+ MiddleBottom: "|",
+ }
+
+ asciiBorder = Border{
+ Top: "-",
+ Bottom: "-",
+ Left: "|",
+ Right: "|",
+ TopLeft: "+",
+ TopRight: "+",
+ BottomLeft: "+",
+ BottomRight: "+",
+ MiddleLeft: "+",
+ MiddleRight: "+",
+ Middle: "+",
+ MiddleTop: "+",
+ MiddleBottom: "+",
+ }
+)
+
+// NormalBorder returns a standard-type border with a normal weight and 90
+// degree corners.
+func NormalBorder() Border {
+ return normalBorder
+}
+
+// RoundedBorder returns a border with rounded corners.
+func RoundedBorder() Border {
+ return roundedBorder
+}
+
+// BlockBorder returns a border that takes the whole block.
+func BlockBorder() Border {
+ return blockBorder
+}
+
+// OuterHalfBlockBorder returns a half-block border that sits outside the frame.
+func OuterHalfBlockBorder() Border {
+ return outerHalfBlockBorder
+}
+
+// InnerHalfBlockBorder returns a half-block border that sits inside the frame.
+func InnerHalfBlockBorder() Border {
+ return innerHalfBlockBorder
+}
+
+// ThickBorder returns a border that's thicker than the one returned by
+// NormalBorder.
+func ThickBorder() Border {
+ return thickBorder
+}
+
+// DoubleBorder returns a border comprised of two thin strokes.
+func DoubleBorder() Border {
+ return doubleBorder
+}
+
+// HiddenBorder returns a border that renders as a series of single-cell
+// spaces. It's useful for cases when you want to remove a standard border but
+// maintain layout positioning. This said, you can still apply a background
+// color to a hidden border.
+func HiddenBorder() Border {
+ return hiddenBorder
+}
+
+// MarkdownBorder return a table border in markdown style.
+//
+// Make sure to disable top and bottom border for the best result. This will
+// ensure that the output is valid markdown.
+//
+// table.New().Border(lipgloss.MarkdownBorder()).BorderTop(false).BorderBottom(false)
+func MarkdownBorder() Border {
+ return markdownBorder
+}
+
+// ASCIIBorder returns a table border with ASCII characters.
+func ASCIIBorder() Border {
+ return asciiBorder
+}
+
+type borderBlend struct {
+ topGradient []color.Color
+ rightGradient []color.Color
+ bottomGradient []color.Color
+ leftGradient []color.Color
+}
+
+func (s Style) borderBlend(width, height int, colors ...color.Color) *borderBlend {
+ gradient := Blend1D(
+ (height+width+2)*2,
+ colors...,
+ )
+
+ // Rotate array forward or reverse based on the offset if provided.
+ if r := -s.getAsInt(borderForegroundBlendOffsetKey); r != 0 {
+ n := len(gradient)
+ r %= n
+ if r < 0 {
+ r += n
+ }
+ slices.Reverse(gradient[:r])
+ slices.Reverse(gradient[r:])
+ slices.Reverse(gradient)
+ }
+
+ offset := 0
+ getFromOffset := func(size int) (s []color.Color) {
+ s = gradient[offset : offset+size]
+ offset += size
+ return s
+ }
+
+ blend := &borderBlend{
+ topGradient: getFromOffset(width + 2),
+ rightGradient: getFromOffset(height),
+ bottomGradient: getFromOffset(width + 2),
+ leftGradient: getFromOffset(height),
+ }
+
+ // bottom and left gradients are reversed because they are drawn in reverse order.
+ slices.Reverse(blend.bottomGradient)
+ slices.Reverse(blend.leftGradient)
+
+ return blend
+}
+
+func (s Style) applyBorder(str string) string {
+ var (
+ border = s.getBorderStyle()
+ hasTop = s.getAsBool(borderTopKey, false)
+ hasRight = s.getAsBool(borderRightKey, false)
+ hasBottom = s.getAsBool(borderBottomKey, false)
+ hasLeft = s.getAsBool(borderLeftKey, false)
+ )
+
+ // If a border is set and no sides have been specifically turned on or off
+ // render borders on all sides.
+ if s.isBorderStyleSetWithoutSides() {
+ hasTop = true
+ hasRight = true
+ hasBottom = true
+ hasLeft = true
+ }
+
+ // If no border is set or all borders are been disabled, abort.
+ if border == noBorder || (!hasTop && !hasRight && !hasBottom && !hasLeft) {
+ return str
+ }
+
+ lines, width := getLines(str)
+
+ if hasLeft {
+ if border.Left == "" {
+ border.Left = " "
+ }
+ width += maxRuneWidth(border.Left)
+ }
+
+ if hasRight {
+ if border.Right == "" {
+ border.Right = " "
+ }
+ width += maxRuneWidth(border.Right)
+ }
+
+ // If corners should be rendered but are set with the empty string, fill them
+ // with a single space.
+ if hasTop && hasLeft && border.TopLeft == "" {
+ border.TopLeft = " "
+ }
+ if hasTop && hasRight && border.TopRight == "" {
+ border.TopRight = " "
+ }
+ if hasBottom && hasLeft && border.BottomLeft == "" {
+ border.BottomLeft = " "
+ }
+ if hasBottom && hasRight && border.BottomRight == "" {
+ border.BottomRight = " "
+ }
+
+ // Figure out which corners we should actually be using based on which
+ // sides are set to show.
+ if hasTop {
+ switch {
+ case !hasLeft && !hasRight:
+ border.TopLeft = ""
+ border.TopRight = ""
+ case !hasLeft:
+ border.TopLeft = ""
+ case !hasRight:
+ border.TopRight = ""
+ }
+ }
+ if hasBottom {
+ switch {
+ case !hasLeft && !hasRight:
+ border.BottomLeft = ""
+ border.BottomRight = ""
+ case !hasLeft:
+ border.BottomLeft = ""
+ case !hasRight:
+ border.BottomRight = ""
+ }
+ }
+
+ // For now, limit corners to one rune.
+ border.TopLeft = getFirstRuneAsString(border.TopLeft)
+ border.TopRight = getFirstRuneAsString(border.TopRight)
+ border.BottomRight = getFirstRuneAsString(border.BottomRight)
+ border.BottomLeft = getFirstRuneAsString(border.BottomLeft)
+
+ var topFG, rightFG, bottomFG, leftFG color.Color
+ var (
+ blendFG = s.getAsColors(borderForegroundBlendKey)
+ topBG = s.getAsColor(borderTopBackgroundKey)
+ rightBG = s.getAsColor(borderRightBackgroundKey)
+ bottomBG = s.getAsColor(borderBottomBackgroundKey)
+ leftBG = s.getAsColor(borderLeftBackgroundKey)
+ )
+
+ var blend *borderBlend
+ if len(blendFG) > 0 {
+ blend = s.borderBlend(width, len(lines), blendFG...)
+ } else {
+ topFG = s.getAsColor(borderTopForegroundKey)
+ rightFG = s.getAsColor(borderRightForegroundKey)
+ bottomFG = s.getAsColor(borderBottomForegroundKey)
+ leftFG = s.getAsColor(borderLeftForegroundKey)
+ }
+
+ var out strings.Builder
+
+ // Render top
+ if hasTop {
+ top := renderHorizontalEdge(border.TopLeft, border.Top, border.TopRight, width)
+ if blend != nil {
+ out.WriteString(s.styleBorderBlend(top, blend.topGradient, topBG))
+ } else {
+ out.WriteString(s.styleBorder(top, topFG, topBG))
+ }
+ out.WriteRune('\n')
+ }
+
+ leftRunes := []rune(border.Left)
+ leftIndex := 0
+
+ rightRunes := []rune(border.Right)
+ rightIndex := 0
+
+ // Render sides
+ var r string
+ for i, l := range lines {
+ if hasLeft {
+ r = string(leftRunes[leftIndex])
+ leftIndex++
+ if leftIndex >= len(leftRunes) {
+ leftIndex = 0
+ }
+ if blend != nil {
+ out.WriteString(s.styleBorder(r, blend.leftGradient[i], leftBG))
+ } else {
+ out.WriteString(s.styleBorder(r, leftFG, leftBG))
+ }
+ }
+ out.WriteString(l)
+ if hasRight {
+ r = string(rightRunes[rightIndex])
+ rightIndex++
+ if rightIndex >= len(rightRunes) {
+ rightIndex = 0
+ }
+ if blend != nil {
+ out.WriteString(s.styleBorder(r, blend.rightGradient[i], rightBG))
+ } else {
+ out.WriteString(s.styleBorder(r, rightFG, rightBG))
+ }
+ }
+ if i < len(lines)-1 {
+ out.WriteRune('\n')
+ }
+ }
+
+ // Render bottom
+ if hasBottom {
+ bottom := renderHorizontalEdge(border.BottomLeft, border.Bottom, border.BottomRight, width)
+ out.WriteRune('\n')
+ if blend != nil {
+ out.WriteString(s.styleBorderBlend(bottom, blend.bottomGradient, bottomBG))
+ } else {
+ out.WriteString(s.styleBorder(bottom, bottomFG, bottomBG))
+ }
+ }
+
+ return out.String()
+}
+
+// Render the horizontal (top or bottom) portion of a border.
+func renderHorizontalEdge(left, middle, right string, width int) string {
+ if middle == "" {
+ middle = " "
+ }
+
+ leftWidth := ansi.StringWidth(left)
+ rightWidth := ansi.StringWidth(right)
+
+ runes := []rune(middle)
+ j := 0
+
+ out := strings.Builder{}
+ out.WriteString(left)
+
+ for i := 0; i < width-leftWidth-rightWidth; {
+ r := runes[j]
+ out.WriteRune(r)
+ i += ansi.StringWidth(string(r))
+ j++
+ if j >= len(runes) {
+ j = 0
+ }
+ }
+
+ out.WriteString(right)
+ return out.String()
+}
+
+// styleBorder applies foreground and background styling to a border.
+func (s Style) styleBorder(border string, fg, bg color.Color) string {
+ if fg == noColor && bg == noColor {
+ return border
+ }
+ var style ansi.Style
+ if fg != noColor {
+ style = style.ForegroundColor(fg)
+ }
+ if bg != noColor {
+ style = style.BackgroundColor(bg)
+ }
+ return style.Styled(border)
+}
+
+// styleBorderBlend applies foreground and background styling to a border, using blending.
+func (s Style) styleBorderBlend(border string, fg []color.Color, bg color.Color) string {
+ var out strings.Builder
+ var style ansi.Style
+ var i int
+
+ gr := uniseg.NewGraphemes(border)
+ for gr.Next() {
+ style = style[:0]
+ if fg[i] != noColor {
+ style = style.ForegroundColor(fg[i])
+ }
+ if bg != noColor {
+ style = style.BackgroundColor(bg)
+ }
+ _, _ = out.WriteString(style.String())
+ _, _ = out.Write(gr.Bytes())
+ i++
+ }
+ _, _ = out.WriteString(ansi.ResetStyle)
+ return out.String()
+}
+
+func maxRuneWidth(str string) int {
+ switch len(str) {
+ case 0:
+ return 0
+ case 1:
+ return displaywidth.String(str)
+ }
+
+ var width int
+
+ g := displaywidth.StringGraphemes(str)
+ for g.Next() {
+ width = max(width, g.Width())
+ }
+ return width
+}
+
+func getFirstRuneAsString(str string) string {
+ if str == "" {
+ return str
+ }
+ _, size := utf8.DecodeRuneInString(str)
+ return str[:size]
+}
diff --git a/vendor/charm.land/lipgloss/v2/canvas.go b/vendor/charm.land/lipgloss/v2/canvas.go
new file mode 100644
index 000000000..396defb8b
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/canvas.go
@@ -0,0 +1,88 @@
+package lipgloss
+
+import (
+ uv "github.com/charmbracelet/ultraviolet"
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Canvas is a cell-buffer that can be used to compose and draw [uv.Drawable]s
+// like [Layer]s.
+//
+// Composed drawables are drawn onto the canvas in the order they were
+// composed, meaning later drawables will appear "on top" of earlier ones.
+//
+// A canvas can read, modify, and render its cell contents.
+//
+// It implements [uv.Screen] and [uv.Drawable].
+type Canvas struct {
+ scr uv.ScreenBuffer
+}
+
+var _ uv.Screen = (*Canvas)(nil)
+
+// NewCanvas creates a new [Canvas] with the given size.
+func NewCanvas(width, height int) *Canvas {
+ c := new(Canvas)
+ c.scr = uv.NewScreenBuffer(width, height)
+ c.scr.Method = ansi.GraphemeWidth
+ return c
+}
+
+// Resize resizes the canvas to the given width and height.
+func (c *Canvas) Resize(width, height int) {
+ c.scr.Resize(width, height)
+}
+
+// Clear clears the canvas.
+func (c *Canvas) Clear() {
+ c.scr.Clear()
+}
+
+// Bounds implements [uv.Screen].
+func (c *Canvas) Bounds() uv.Rectangle {
+ return c.scr.Bounds()
+}
+
+// Width returns the width of the canvas.
+func (c *Canvas) Width() int {
+ return c.scr.Width()
+}
+
+// Height returns the height of the canvas.
+func (c *Canvas) Height() int {
+ return c.scr.Height()
+}
+
+// CellAt implements [uv.Screen].
+func (c *Canvas) CellAt(x int, y int) *uv.Cell {
+ return c.scr.CellAt(x, y)
+}
+
+// SetCell implements [uv.Screen].
+func (c *Canvas) SetCell(x int, y int, cell *uv.Cell) {
+ c.scr.SetCell(x, y, cell)
+}
+
+// WidthMethod implements [uv.Screen].
+func (c *Canvas) WidthMethod() uv.WidthMethod {
+ return c.scr.WidthMethod()
+}
+
+// Compose composes a [Layer] or any [uv.Drawable] onto the [Canvas].
+func (c *Canvas) Compose(drawer uv.Drawable) *Canvas {
+ drawer.Draw(c, c.Bounds())
+ return c
+}
+
+// Draw draws the [Canvas] onto the given [uv.Screen] within the specified
+// area.
+//
+// It implements [uv.Drawable].
+func (c *Canvas) Draw(scr uv.Screen, area uv.Rectangle) {
+ c.scr.Draw(scr, area)
+}
+
+// Render renders the canvas into a styled string.
+func (c *Canvas) Render() string {
+ return c.scr.Render()
+}
diff --git a/vendor/charm.land/lipgloss/v2/color.go b/vendor/charm.land/lipgloss/v2/color.go
new file mode 100644
index 000000000..7443dc10b
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/color.go
@@ -0,0 +1,359 @@
+package lipgloss
+
+import (
+ "cmp"
+ "errors"
+ "image/color"
+ "strconv"
+ "strings"
+
+ "github.com/charmbracelet/colorprofile"
+ "github.com/charmbracelet/x/ansi"
+ "github.com/lucasb-eyer/go-colorful"
+)
+
+func clamp[T cmp.Ordered](v, low, high T) T {
+ if high < low {
+ high, low = low, high
+ }
+ return min(high, max(low, v))
+}
+
+// 4-bit color constants.
+const (
+ Black ansi.BasicColor = iota
+ Red
+ Green
+ Yellow
+ Blue
+ Magenta
+ Cyan
+ White
+
+ BrightBlack
+ BrightRed
+ BrightGreen
+ BrightYellow
+ BrightBlue
+ BrightMagenta
+ BrightCyan
+ BrightWhite
+)
+
+var noColor = NoColor{}
+
+// NoColor is used to specify the absence of color styling. When this is active
+// foreground colors will be rendered with the terminal's default text color,
+// and background colors will not be drawn at all.
+//
+// Example usage:
+//
+// var style = someStyle.Background(lipgloss.NoColor{})
+type NoColor struct{}
+
+// RGBA returns the RGBA value of this color. Because we have to return
+// something, despite this color being the absence of color, we're returning
+// black with 100% opacity.
+//
+// Red: 0x0, Green: 0x0, Blue: 0x0, Alpha: 0xFFFF.
+func (n NoColor) RGBA() (r, g, b, a uint32) {
+ return 0x0, 0x0, 0x0, 0xFFFF //nolint:mnd
+}
+
+// Color specifies a color by hex or ANSI256 value. For example:
+//
+// ansiColor := lipgloss.Color("1") // The same as lipgloss.Red
+// ansi256Color := lipgloss.Color("21")
+// hexColor := lipgloss.Color("#0000ff")
+func Color(s string) color.Color {
+ if strings.HasPrefix(s, "#") {
+ c, err := parseHex(s)
+ if err != nil {
+ return noColor
+ }
+ return c
+ }
+
+ i, err := strconv.Atoi(s)
+ if err != nil {
+ return noColor
+ }
+
+ if i < 0 {
+ // Only positive numbers
+ i = -i
+ }
+
+ if i < 16 {
+ return ansi.BasicColor(i) //nolint:gosec
+ } else if i < 256 {
+ return ANSIColor(i) //nolint:gosec
+ }
+
+ r, g, b := uint8((i>>16)&0xff), uint8(i>>8&0xff), uint8(i&0xff) //nolint:gosec
+ return color.RGBA{R: r, G: g, B: b, A: 0xff}
+}
+
+var errInvalidFormat = errors.New("invalid hex format") // pre-allocated.
+
+// parseHex parses a hex color string and returns a color.RGBA. The string can be
+// in the format #RRGGBB or #RGB. This is a more performant implementation of
+// [colorful.Hex].
+func parseHex(s string) (c color.RGBA, err error) {
+ c.A = 0xff
+
+ if len(s) == 0 || s[0] != '#' {
+ return c, errInvalidFormat
+ }
+
+ hexToByte := func(b byte) byte {
+ switch {
+ case b >= '0' && b <= '9':
+ return b - '0'
+ case b >= 'a' && b <= 'f':
+ return b - 'a' + 10
+ case b >= 'A' && b <= 'F':
+ return b - 'A' + 10
+ }
+ err = errInvalidFormat
+ return 0
+ }
+
+ switch len(s) {
+ case 7:
+ c.R = hexToByte(s[1])<<4 + hexToByte(s[2])
+ c.G = hexToByte(s[3])<<4 + hexToByte(s[4])
+ c.B = hexToByte(s[5])<<4 + hexToByte(s[6])
+ case 4:
+ c.R = hexToByte(s[1]) * 17
+ c.G = hexToByte(s[2]) * 17
+ c.B = hexToByte(s[3]) * 17
+ default:
+ err = errInvalidFormat
+ }
+ return c, err
+}
+
+// RGBColor is a color specified by red, green, and blue values.
+type RGBColor struct {
+ R uint8
+ G uint8
+ B uint8
+}
+
+// RGBA returns the RGBA value of this color. This satisfies the Go Color
+// interface.
+func (c RGBColor) RGBA() (r, g, b, a uint32) {
+ const shift = 8
+ r |= uint32(c.R) << shift
+ g |= uint32(c.G) << shift
+ b |= uint32(c.B) << shift
+ a = 0xFFFF
+ return
+}
+
+// ANSIColor is a color specified by an ANSI256 color value.
+//
+// Example usage:
+//
+// colorA := lipgloss.ANSIColor(8)
+// colorB := lipgloss.ANSIColor(134)
+type ANSIColor = ansi.IndexedColor
+
+// LightDarkFunc is a function that returns a color based on whether the
+// terminal has a light or dark background. You can create one of these with
+// [LightDark].
+//
+// Example:
+//
+// lightDark := lipgloss.LightDark(hasDarkBackground)
+// red, blue := lipgloss.Color("#ff0000"), lipgloss.Color("#0000ff")
+// myHotColor := lightDark(red, blue)
+//
+// For more info see [LightDark].
+type LightDarkFunc func(light, dark color.Color) color.Color
+
+// LightDark is a simple helper type that can be used to choose the appropriate
+// color based on whether the terminal has a light or dark background.
+//
+// lightDark := lipgloss.LightDark(hasDarkBackground)
+// red, blue := lipgloss.Color("#ff0000"), lipgloss.Color("#0000ff")
+// myHotColor := lightDark(red, blue)
+//
+// In practice, there are slightly different workflows between Bubble Tea and
+// Lip Gloss standalone.
+//
+// In Bubble Tea, listen for tea.BackgroundColorMsg, which automatically
+// flows through Update on start. This message will be received whenever the
+// background color changes:
+//
+// case tea.BackgroundColorMsg:
+// m.hasDarkBackground = msg.IsDark()
+//
+// Later, when you're rendering use:
+//
+// lightDark := lipgloss.LightDark(m.hasDarkBackground)
+// red, blue := lipgloss.Color("#ff0000"), lipgloss.Color("#0000ff")
+// myHotColor := lightDark(red, blue)
+//
+// In standalone Lip Gloss, the workflow is simpler:
+//
+// hasDarkBG := lipgloss.HasDarkBackground(os.Stdin, os.Stdout)
+// lightDark := lipgloss.LightDark(hasDarkBG)
+// red, blue := lipgloss.Color("#ff0000"), lipgloss.Color("#0000ff")
+// myHotColor := lightDark(red, blue)
+func LightDark(isDark bool) LightDarkFunc {
+ return func(light, dark color.Color) color.Color {
+ if isDark {
+ return dark
+ }
+ return light
+ }
+}
+
+// isDarkColor returns whether the given color is dark (based on the luminance
+// portion of the color as interpreted as HSL).
+//
+// Example usage:
+//
+// color := lipgloss.Color("#0000ff")
+// if lipgloss.isDarkColor(color) {
+// fmt.Println("It's dark! I love darkness!")
+// } else {
+// fmt.Println("It's light! Cover your eyes!")
+// }
+func isDarkColor(c color.Color) bool {
+ col, ok := colorful.MakeColor(c)
+ if !ok {
+ return true
+ }
+
+ _, _, l := col.Hsl()
+ return l < 0.5 //nolint:mnd
+}
+
+// CompleteFunc is a function that returns the appropriate color based on the
+// given color profile.
+//
+// Example usage:
+//
+// p := colorprofile.Detect(os.Stderr, os.Environ())
+// complete := lipgloss.Complete(p)
+// color := complete(
+// lipgloss.Color(1), // ANSI
+// lipgloss.Color(124), // ANSI256
+// lipgloss.Color("#ff34ac"), // TrueColor
+// )
+// fmt.Println("Ooh, pretty color: ", color)
+//
+// For more info see [Complete].
+type CompleteFunc func(ansi, ansi256, truecolor color.Color) color.Color
+
+// Complete returns a function that will return the appropriate color based on
+// the given color profile.
+//
+// Example usage:
+//
+// p := colorprofile.Detect(os.Stderr, os.Environ())
+// complete := lipgloss.Complete(p)
+// color := complete(
+// lipgloss.Color(1), // ANSI
+// lipgloss.Color(124), // ANSI256
+// lipgloss.Color("#ff34ac"), // TrueColor
+// )
+// fmt.Println("Ooh, pretty color: ", color)
+func Complete(p colorprofile.Profile) CompleteFunc {
+ return func(ansi, ansi256, truecolor color.Color) color.Color {
+ switch p { //nolint:exhaustive
+ case colorprofile.ANSI:
+ return ansi
+ case colorprofile.ANSI256:
+ return ansi256
+ case colorprofile.TrueColor:
+ return truecolor
+ }
+ return noColor
+ }
+}
+
+// ensureNotTransparent ensures that the alpha value of a color is not 0, and if
+// it is, we will set it to 1. This is useful for when we are converting from
+// RGB -> RGBA, and the alpha value is lost in the conversion for gradient purposes.
+func ensureNotTransparent(c color.Color) color.Color {
+ _, _, _, a := c.RGBA()
+ if a == 0 {
+ return Alpha(c, 1)
+ }
+ return c
+}
+
+// Alpha adjusts the alpha value of a color using a 0-1 (clamped) float scale
+// 0 = transparent, 1 = opaque.
+func Alpha(c color.Color, alpha float64) color.Color {
+ if c == nil {
+ return nil
+ }
+
+ r, g, b, _ := c.RGBA()
+ return color.RGBA{
+ R: uint8(min(255, float64(r>>8))),
+ G: uint8(min(255, float64(g>>8))),
+ B: uint8(min(255, float64(b>>8))),
+ A: uint8(clamp(alpha, 0, 1) * 255),
+ }
+}
+
+// Complementary returns the complementary color (180° away on color wheel) of
+// the given color. This is useful for creating a contrasting color.
+func Complementary(c color.Color) color.Color {
+ if c == nil {
+ return nil
+ }
+
+ // Offset hue by 180°.
+ cf, _ := colorful.MakeColor(ensureNotTransparent(c))
+
+ h, s, v := cf.Hsv()
+ h += 180
+ if h >= 360 {
+ h -= 360
+ } else if h < 0 {
+ h += 360
+ }
+
+ return colorful.Hsv(h, s, v).Clamped()
+}
+
+// Darken takes a color and makes it darker by a specific percentage (0-1, clamped).
+func Darken(c color.Color, percent float64) color.Color {
+ if c == nil {
+ return nil
+ }
+
+ mult := 1.0 - clamp(percent, 0, 1)
+
+ r, g, b, a := c.RGBA()
+ return color.RGBA{
+ R: uint8(float64(r>>8) * mult),
+ G: uint8(float64(g>>8) * mult),
+ B: uint8(float64(b>>8) * mult),
+ A: uint8(min(255, float64(a>>8))),
+ }
+}
+
+// Lighten makes a color lighter by a specific percentage (0-1, clamped).
+func Lighten(c color.Color, percent float64) color.Color {
+ if c == nil {
+ return nil
+ }
+
+ add := 255 * (clamp(percent, 0, 1))
+
+ r, g, b, a := c.RGBA()
+ return color.RGBA{
+ R: uint8(min(255, float64(r>>8)+add)),
+ G: uint8(min(255, float64(g>>8)+add)),
+ B: uint8(min(255, float64(b>>8)+add)),
+ A: uint8(min(255, float64(a>>8))),
+ }
+}
diff --git a/vendor/charm.land/lipgloss/v2/get.go b/vendor/charm.land/lipgloss/v2/get.go
new file mode 100644
index 000000000..d1fe1d669
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/get.go
@@ -0,0 +1,657 @@
+package lipgloss
+
+import (
+ "image/color"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// GetBold returns the style's bold value. If no value is set false is returned.
+func (s Style) GetBold() bool {
+ return s.getAsBool(boldKey, false)
+}
+
+// GetItalic returns the style's italic value. If no value is set false is
+// returned.
+func (s Style) GetItalic() bool {
+ return s.getAsBool(italicKey, false)
+}
+
+// GetUnderline returns the style's underline value. If no value is set false is
+// returned.
+func (s Style) GetUnderline() bool {
+ return s.ul != UnderlineNone
+}
+
+// GetUnderlineStyle returns the style's underline style. If no value is set
+// UnderlineNone is returned.
+func (s Style) GetUnderlineStyle() Underline {
+ return s.ul
+}
+
+// GetUnderlineColor returns the style's underline color. If no value is set
+// NoColor{} is returned.
+func (s Style) GetUnderlineColor() color.Color {
+ return s.getAsColor(underlineColorKey)
+}
+
+// GetStrikethrough returns the style's strikethrough value. If no value is set false
+// is returned.
+func (s Style) GetStrikethrough() bool {
+ return s.getAsBool(strikethroughKey, false)
+}
+
+// GetReverse returns the style's reverse value. If no value is set false is
+// returned.
+func (s Style) GetReverse() bool {
+ return s.getAsBool(reverseKey, false)
+}
+
+// GetBlink returns the style's blink value. If no value is set false is
+// returned.
+func (s Style) GetBlink() bool {
+ return s.getAsBool(blinkKey, false)
+}
+
+// GetFaint returns the style's faint value. If no value is set false is
+// returned.
+func (s Style) GetFaint() bool {
+ return s.getAsBool(faintKey, false)
+}
+
+// GetForeground returns the style's foreground color. If no value is set
+// NoColor{} is returned.
+func (s Style) GetForeground() color.Color {
+ return s.getAsColor(foregroundKey)
+}
+
+// GetBackground returns the style's background color. If no value is set
+// NoColor{} is returned.
+func (s Style) GetBackground() color.Color {
+ return s.getAsColor(backgroundKey)
+}
+
+// GetWidth returns the style's width setting. If no width is set 0 is
+// returned.
+func (s Style) GetWidth() int {
+ return s.getAsInt(widthKey)
+}
+
+// GetHeight returns the style's height setting. If no height is set 0 is
+// returned.
+func (s Style) GetHeight() int {
+ return s.getAsInt(heightKey)
+}
+
+// GetAlign returns the style's implicit horizontal alignment setting.
+// If no alignment is set Position.Left is returned.
+func (s Style) GetAlign() Position {
+ v := s.getAsPosition(alignHorizontalKey)
+ if v == Position(0) {
+ return Left
+ }
+ return v
+}
+
+// GetAlignHorizontal returns the style's implicit horizontal alignment setting.
+// If no alignment is set Position.Left is returned.
+func (s Style) GetAlignHorizontal() Position {
+ v := s.getAsPosition(alignHorizontalKey)
+ if v == Position(0) {
+ return Left
+ }
+ return v
+}
+
+// GetAlignVertical returns the style's implicit vertical alignment setting.
+// If no alignment is set Position.Top is returned.
+func (s Style) GetAlignVertical() Position {
+ v := s.getAsPosition(alignVerticalKey)
+ if v == Position(0) {
+ return Top
+ }
+ return v
+}
+
+// GetPadding returns the style's top, right, bottom, and left padding values,
+// in that order. 0 is returned for unset values.
+func (s Style) GetPadding() (top, right, bottom, left int) {
+ return s.getAsInt(paddingTopKey),
+ s.getAsInt(paddingRightKey),
+ s.getAsInt(paddingBottomKey),
+ s.getAsInt(paddingLeftKey)
+}
+
+// GetPaddingTop returns the style's top padding. If no value is set 0 is
+// returned.
+func (s Style) GetPaddingTop() int {
+ return s.getAsInt(paddingTopKey)
+}
+
+// GetPaddingRight returns the style's right padding. If no value is set 0 is
+// returned.
+func (s Style) GetPaddingRight() int {
+ return s.getAsInt(paddingRightKey)
+}
+
+// GetPaddingBottom returns the style's bottom padding. If no value is set 0 is
+// returned.
+func (s Style) GetPaddingBottom() int {
+ return s.getAsInt(paddingBottomKey)
+}
+
+// GetPaddingLeft returns the style's left padding. If no value is set 0 is
+// returned.
+func (s Style) GetPaddingLeft() int {
+ return s.getAsInt(paddingLeftKey)
+}
+
+// GetPaddingChar returns the style's padding character. If no value is set a
+// space is returned.
+func (s Style) GetPaddingChar() rune {
+ char := s.getAsRune(paddingCharKey)
+ if char == 0 {
+ return ' '
+ }
+ return char
+}
+
+// GetHorizontalPadding returns the style's left and right padding. Unset
+// values are measured as 0.
+func (s Style) GetHorizontalPadding() int {
+ return s.getAsInt(paddingLeftKey) + s.getAsInt(paddingRightKey)
+}
+
+// GetVerticalPadding returns the style's top and bottom padding. Unset values
+// are measured as 0.
+func (s Style) GetVerticalPadding() int {
+ return s.getAsInt(paddingTopKey) + s.getAsInt(paddingBottomKey)
+}
+
+// GetColorWhitespace returns the style's whitespace coloring setting. If no
+// value is set false is returned.
+func (s Style) GetColorWhitespace() bool {
+ return s.getAsBool(colorWhitespaceKey, false)
+}
+
+// GetMargin returns the style's top, right, bottom, and left margins, in that
+// order. 0 is returned for unset values.
+func (s Style) GetMargin() (top, right, bottom, left int) {
+ return s.getAsInt(marginTopKey),
+ s.getAsInt(marginRightKey),
+ s.getAsInt(marginBottomKey),
+ s.getAsInt(marginLeftKey)
+}
+
+// GetMarginTop returns the style's top margin. If no value is set 0 is
+// returned.
+func (s Style) GetMarginTop() int {
+ return s.getAsInt(marginTopKey)
+}
+
+// GetMarginRight returns the style's right margin. If no value is set 0 is
+// returned.
+func (s Style) GetMarginRight() int {
+ return s.getAsInt(marginRightKey)
+}
+
+// GetMarginBottom returns the style's bottom margin. If no value is set 0 is
+// returned.
+func (s Style) GetMarginBottom() int {
+ return s.getAsInt(marginBottomKey)
+}
+
+// GetMarginLeft returns the style's left margin. If no value is set 0 is
+// returned.
+func (s Style) GetMarginLeft() int {
+ return s.getAsInt(marginLeftKey)
+}
+
+// GetMarginChar returns the style's padding character. If no value is set a
+// space is returned.
+func (s Style) GetMarginChar() rune {
+ char := s.getAsRune(marginCharKey)
+ if char == 0 {
+ return ' '
+ }
+ return char
+}
+
+// GetHorizontalMargins returns the style's left and right margins. Unset
+// values are measured as 0.
+func (s Style) GetHorizontalMargins() int {
+ return s.getAsInt(marginLeftKey) + s.getAsInt(marginRightKey)
+}
+
+// GetVerticalMargins returns the style's top and bottom margins. Unset values
+// are measured as 0.
+func (s Style) GetVerticalMargins() int {
+ return s.getAsInt(marginTopKey) + s.getAsInt(marginBottomKey)
+}
+
+// GetBorder returns the style's border style (type Border) and value for the
+// top, right, bottom, and left in that order. If no value is set for the
+// border style, Border{} is returned. For all other unset values false is
+// returned.
+func (s Style) GetBorder() (b Border, top, right, bottom, left bool) {
+ return s.getBorderStyle(),
+ s.getAsBool(borderTopKey, false),
+ s.getAsBool(borderRightKey, false),
+ s.getAsBool(borderBottomKey, false),
+ s.getAsBool(borderLeftKey, false)
+}
+
+// GetBorderStyle returns the style's border style (type Border). If no value
+// is set Border{} is returned.
+func (s Style) GetBorderStyle() Border {
+ return s.getBorderStyle()
+}
+
+// GetBorderTop returns the style's top border setting. If no value is set
+// false is returned.
+func (s Style) GetBorderTop() bool {
+ return s.getAsBool(borderTopKey, false)
+}
+
+// GetBorderRight returns the style's right border setting. If no value is set
+// false is returned.
+func (s Style) GetBorderRight() bool {
+ return s.getAsBool(borderRightKey, false)
+}
+
+// GetBorderBottom returns the style's bottom border setting. If no value is
+// set false is returned.
+func (s Style) GetBorderBottom() bool {
+ return s.getAsBool(borderBottomKey, false)
+}
+
+// GetBorderLeft returns the style's left border setting. If no value is
+// set false is returned.
+func (s Style) GetBorderLeft() bool {
+ return s.getAsBool(borderLeftKey, false)
+}
+
+// GetBorderTopForeground returns the style's border top foreground color. If
+// no value is set NoColor{} is returned.
+func (s Style) GetBorderTopForeground() color.Color {
+ return s.getAsColor(borderTopForegroundKey)
+}
+
+// GetBorderRightForeground returns the style's border right foreground color.
+// If no value is set NoColor{} is returned.
+func (s Style) GetBorderRightForeground() color.Color {
+ return s.getAsColor(borderRightForegroundKey)
+}
+
+// GetBorderBottomForeground returns the style's border bottom foreground
+// color. If no value is set NoColor{} is returned.
+func (s Style) GetBorderBottomForeground() color.Color {
+ return s.getAsColor(borderBottomForegroundKey)
+}
+
+// GetBorderLeftForeground returns the style's border left foreground
+// color. If no value is set NoColor{} is returned.
+func (s Style) GetBorderLeftForeground() color.Color {
+ return s.getAsColor(borderLeftForegroundKey)
+}
+
+// GetBorderForegroundBlend returns the style's border blend foreground
+// colors. If no value is set, nil is returned.
+func (s Style) GetBorderForegroundBlend() []color.Color {
+ return s.getAsColors(borderForegroundBlendKey)
+}
+
+// GetBorderForegroundBlendOffset returns the style's border blend offset. If no
+// value is set, 0 is returned.
+func (s Style) GetBorderForegroundBlendOffset() int {
+ return s.getAsInt(borderForegroundBlendOffsetKey)
+}
+
+// GetBorderTopBackground returns the style's border top background color. If
+// no value is set NoColor{} is returned.
+func (s Style) GetBorderTopBackground() color.Color {
+ return s.getAsColor(borderTopBackgroundKey)
+}
+
+// GetBorderRightBackground returns the style's border right background color.
+// If no value is set NoColor{} is returned.
+func (s Style) GetBorderRightBackground() color.Color {
+ return s.getAsColor(borderRightBackgroundKey)
+}
+
+// GetBorderBottomBackground returns the style's border bottom background
+// color. If no value is set NoColor{} is returned.
+func (s Style) GetBorderBottomBackground() color.Color {
+ return s.getAsColor(borderBottomBackgroundKey)
+}
+
+// GetBorderLeftBackground returns the style's border left background
+// color. If no value is set NoColor{} is returned.
+func (s Style) GetBorderLeftBackground() color.Color {
+ return s.getAsColor(borderLeftBackgroundKey)
+}
+
+// GetBorderTopWidth returns the width of the top border. If borders contain
+// runes of varying widths, the widest rune is returned. If no border exists on
+// the top edge, 0 is returned.
+//
+// Deprecated: This function simply calls Style.GetBorderTopSize.
+func (s Style) GetBorderTopWidth() int {
+ return s.GetBorderTopSize()
+}
+
+// GetBorderTopSize returns the width of the top border. If borders contain
+// runes of varying widths, the widest rune is returned. If no border exists on
+// the top edge, 0 is returned.
+func (s Style) GetBorderTopSize() int {
+ if s.isBorderStyleSetWithoutSides() {
+ return 1
+ }
+ if !s.getAsBool(borderTopKey, false) {
+ return 0
+ }
+ return s.getBorderStyle().GetTopSize()
+}
+
+// GetBorderLeftSize returns the width of the left border. If borders contain
+// runes of varying widths, the widest rune is returned. If no border exists on
+// the left edge, 0 is returned.
+func (s Style) GetBorderLeftSize() int {
+ if s.isBorderStyleSetWithoutSides() {
+ return 1
+ }
+ if !s.getAsBool(borderLeftKey, false) {
+ return 0
+ }
+ return s.getBorderStyle().GetLeftSize()
+}
+
+// GetBorderBottomSize returns the width of the bottom border. If borders
+// contain runes of varying widths, the widest rune is returned. If no border
+// exists on the left edge, 0 is returned.
+func (s Style) GetBorderBottomSize() int {
+ if s.isBorderStyleSetWithoutSides() {
+ return 1
+ }
+ if !s.getAsBool(borderBottomKey, false) {
+ return 0
+ }
+ return s.getBorderStyle().GetBottomSize()
+}
+
+// GetBorderRightSize returns the width of the right border. If borders
+// contain runes of varying widths, the widest rune is returned. If no border
+// exists on the right edge, 0 is returned.
+func (s Style) GetBorderRightSize() int {
+ if s.isBorderStyleSetWithoutSides() {
+ return 1
+ }
+ if !s.getAsBool(borderRightKey, false) {
+ return 0
+ }
+ return s.getBorderStyle().GetRightSize()
+}
+
+// GetHorizontalBorderSize returns the width of the horizontal borders. If
+// borders contain runes of varying widths, the widest rune is returned. If no
+// border exists on the horizontal edges, 0 is returned.
+func (s Style) GetHorizontalBorderSize() int {
+ return s.GetBorderLeftSize() + s.GetBorderRightSize()
+}
+
+// GetVerticalBorderSize returns the width of the vertical borders. If
+// borders contain runes of varying widths, the widest rune is returned. If no
+// border exists on the vertical edges, 0 is returned.
+func (s Style) GetVerticalBorderSize() int {
+ return s.GetBorderTopSize() + s.GetBorderBottomSize()
+}
+
+// GetInline returns the style's inline setting. If no value is set false is
+// returned.
+func (s Style) GetInline() bool {
+ return s.getAsBool(inlineKey, false)
+}
+
+// GetMaxWidth returns the style's max width setting. If no value is set 0 is
+// returned.
+func (s Style) GetMaxWidth() int {
+ return s.getAsInt(maxWidthKey)
+}
+
+// GetMaxHeight returns the style's max height setting. If no value is set 0 is
+// returned.
+func (s Style) GetMaxHeight() int {
+ return s.getAsInt(maxHeightKey)
+}
+
+// GetTabWidth returns the style's tab width setting. If no value is set 4 is
+// returned which is the implicit default.
+func (s Style) GetTabWidth() int {
+ return s.getAsInt(tabWidthKey)
+}
+
+// GetUnderlineSpaces returns whether or not the style is set to underline
+// spaces. If not value is set false is returned.
+func (s Style) GetUnderlineSpaces() bool {
+ return s.getAsBool(underlineSpacesKey, false)
+}
+
+// GetStrikethroughSpaces returns whether or not the style is set to strikethrough
+// spaces. If not value is set false is returned.
+func (s Style) GetStrikethroughSpaces() bool {
+ return s.getAsBool(strikethroughSpacesKey, false)
+}
+
+// GetHorizontalFrameSize returns the sum of the style's horizontal margins, padding
+// and border widths.
+//
+// Provisional: this method may be renamed.
+func (s Style) GetHorizontalFrameSize() int {
+ return s.GetHorizontalMargins() + s.GetHorizontalPadding() + s.GetHorizontalBorderSize()
+}
+
+// GetVerticalFrameSize returns the sum of the style's vertical margins, padding
+// and border widths.
+//
+// Provisional: this method may be renamed.
+func (s Style) GetVerticalFrameSize() int {
+ return s.GetVerticalMargins() + s.GetVerticalPadding() + s.GetVerticalBorderSize()
+}
+
+// GetFrameSize returns the sum of the margins, padding and border width for
+// both the horizontal and vertical margins.
+func (s Style) GetFrameSize() (x, y int) {
+ return s.GetHorizontalFrameSize(), s.GetVerticalFrameSize()
+}
+
+// GetTransform returns the transform set on the style. If no transform is set
+// nil is returned.
+func (s Style) GetTransform() func(string) string {
+ return s.getAsTransform(transformKey)
+}
+
+// GetHyperlink returns the hyperlink along with its parameters. If no
+// hyperlink is set, empty strings are returned.
+func (s Style) GetHyperlink() (link, params string) {
+ if s.isSet(linkKey) {
+ link = s.link
+ }
+ if s.isSet(linkParamsKey) {
+ params = s.linkParams
+ }
+ return
+}
+
+// Returns whether or not the given property is set.
+func (s Style) isSet(k propKey) bool {
+ return s.props.has(k)
+}
+
+func (s Style) getAsRune(k propKey) rune {
+ if !s.isSet(k) {
+ return 0
+ }
+ switch k { //nolint:exhaustive
+ case paddingCharKey:
+ return s.paddingChar
+ case marginCharKey:
+ return s.marginChar
+ }
+ return 0
+}
+
+func (s Style) getAsBool(k propKey, defaultVal bool) bool {
+ if !s.isSet(k) {
+ return defaultVal
+ }
+ return s.attrs&int(k) != 0
+}
+
+func (s Style) getAsColors(k propKey) (colors []color.Color) {
+ if !s.isSet(k) {
+ return nil
+ }
+
+ switch k { //nolint:exhaustive
+ case borderForegroundBlendKey:
+ return s.borderBlendFgColor
+ }
+
+ return nil
+}
+
+func (s Style) getAsColor(k propKey) color.Color {
+ if !s.isSet(k) {
+ return noColor
+ }
+
+ var c color.Color
+ switch k { //nolint:exhaustive
+ case foregroundKey:
+ c = s.fgColor
+ case backgroundKey:
+ c = s.bgColor
+ case marginBackgroundKey:
+ c = s.marginBgColor
+ case borderTopForegroundKey:
+ c = s.borderTopFgColor
+ case borderRightForegroundKey:
+ c = s.borderRightFgColor
+ case borderBottomForegroundKey:
+ c = s.borderBottomFgColor
+ case borderLeftForegroundKey:
+ c = s.borderLeftFgColor
+ case borderTopBackgroundKey:
+ c = s.borderTopBgColor
+ case borderRightBackgroundKey:
+ c = s.borderRightBgColor
+ case borderBottomBackgroundKey:
+ c = s.borderBottomBgColor
+ case borderLeftBackgroundKey:
+ c = s.borderLeftBgColor
+ case underlineColorKey:
+ c = s.ulColor
+ }
+
+ if c != nil {
+ return c
+ }
+
+ return noColor
+}
+
+func (s Style) getAsInt(k propKey) int {
+ if !s.isSet(k) {
+ return 0
+ }
+ switch k { //nolint:exhaustive
+ case widthKey:
+ return s.width
+ case heightKey:
+ return s.height
+ case paddingTopKey:
+ return s.paddingTop
+ case paddingRightKey:
+ return s.paddingRight
+ case paddingBottomKey:
+ return s.paddingBottom
+ case paddingLeftKey:
+ return s.paddingLeft
+ case marginTopKey:
+ return s.marginTop
+ case marginRightKey:
+ return s.marginRight
+ case marginBottomKey:
+ return s.marginBottom
+ case marginLeftKey:
+ return s.marginLeft
+ case borderForegroundBlendOffsetKey:
+ return s.borderForegroundBlendOffset
+ case maxWidthKey:
+ return s.maxWidth
+ case maxHeightKey:
+ return s.maxHeight
+ case tabWidthKey:
+ return s.tabWidth
+ }
+ return 0
+}
+
+func (s Style) getAsPosition(k propKey) Position {
+ if !s.isSet(k) {
+ return Position(0)
+ }
+ switch k { //nolint:exhaustive
+ case alignHorizontalKey:
+ return s.alignHorizontal
+ case alignVerticalKey:
+ return s.alignVertical
+ }
+ return Position(0)
+}
+
+func (s Style) getBorderStyle() Border {
+ if !s.isSet(borderStyleKey) {
+ return noBorder
+ }
+ return s.borderStyle
+}
+
+func (s Style) getAsTransform(propKey) func(string) string {
+ if !s.isSet(transformKey) {
+ return nil
+ }
+ return s.transform
+}
+
+// Split a string into lines, additionally returning the size of the widest
+// line.
+func getLines(s string) (lines []string, widest int) {
+ s = strings.ReplaceAll(s, "\t", " ")
+ s = strings.ReplaceAll(s, "\r\n", "\n")
+ lines = strings.Split(s, "\n")
+
+ for _, l := range lines {
+ w := ansi.StringWidth(l)
+ if widest < w {
+ widest = w
+ }
+ }
+
+ return lines, widest
+}
+
+// isBorderStyleSetWithoutSides returns true if the border style is set but no
+// sides are set. This is used to determine if the border should be rendered by
+// default.
+func (s Style) isBorderStyleSetWithoutSides() bool {
+ var (
+ border = s.getBorderStyle()
+ topSet = s.isSet(borderTopKey)
+ rightSet = s.isSet(borderRightKey)
+ bottomSet = s.isSet(borderBottomKey)
+ leftSet = s.isSet(borderLeftKey)
+ )
+ return border != noBorder && !(topSet || rightSet || bottomSet || leftSet) //nolint:staticcheck
+}
diff --git a/vendor/charm.land/lipgloss/v2/join.go b/vendor/charm.land/lipgloss/v2/join.go
new file mode 100644
index 000000000..349ae552f
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/join.go
@@ -0,0 +1,175 @@
+package lipgloss
+
+import (
+ "math"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// JoinHorizontal is a utility function for horizontally joining two
+// potentially multi-lined strings along a vertical axis. The first argument is
+// the position, with 0 being all the way at the top and 1 being all the way
+// at the bottom.
+//
+// If you just want to align to the top, center or bottom you may as well just
+// use the helper constants Top, Center, and Bottom.
+//
+// Example:
+//
+// blockB := "...\n...\n..."
+// blockA := "...\n...\n...\n...\n..."
+//
+// // Join 20% from the top
+// str := lipgloss.JoinHorizontal(0.2, blockA, blockB)
+//
+// // Join on the top edge
+// str := lipgloss.JoinHorizontal(lipgloss.Top, blockA, blockB)
+func JoinHorizontal(pos Position, strs ...string) string {
+ if len(strs) == 0 {
+ return ""
+ }
+ if len(strs) == 1 {
+ return strs[0]
+ }
+
+ var (
+ // Groups of strings broken into multiple lines
+ blocks = make([][]string, len(strs))
+
+ // Max line widths for the above text blocks
+ maxWidths = make([]int, len(strs))
+
+ // Height of the tallest block
+ maxHeight int
+ )
+
+ // Break text blocks into lines and get max widths for each text block
+ for i, str := range strs {
+ blocks[i], maxWidths[i] = getLines(str)
+ if len(blocks[i]) > maxHeight {
+ maxHeight = len(blocks[i])
+ }
+ }
+
+ // Add extra lines to make each side the same height
+ for i := range blocks {
+ if len(blocks[i]) >= maxHeight {
+ continue
+ }
+
+ extraLines := make([]string, maxHeight-len(blocks[i]))
+
+ switch pos {
+ case Top:
+ blocks[i] = append(blocks[i], extraLines...)
+
+ case Bottom:
+ blocks[i] = append(extraLines, blocks[i]...)
+
+ default: // Somewhere in the middle
+ n := len(extraLines)
+ split := int(math.Round(float64(n) * pos.value()))
+ top := n - split
+ bottom := n - top
+
+ blocks[i] = append(extraLines[top:], blocks[i]...)
+ blocks[i] = append(blocks[i], extraLines[bottom:]...)
+ }
+ }
+
+ // Merge lines
+ var b strings.Builder
+ for i := range blocks[0] { // remember, all blocks have the same number of members now
+ for j, block := range blocks {
+ b.WriteString(block[i])
+
+ // Also make lines the same length
+ b.WriteString(strings.Repeat(" ", maxWidths[j]-ansi.StringWidth(block[i])))
+ }
+ if i < len(blocks[0])-1 {
+ b.WriteRune('\n')
+ }
+ }
+
+ return b.String()
+}
+
+// JoinVertical is a utility function for vertically joining two potentially
+// multi-lined strings along a horizontal axis. The first argument is the
+// position, with 0 being all the way to the left and 1 being all the way to
+// the right.
+//
+// If you just want to align to the left, right or center you may as well just
+// use the helper constants Left, Center, and Right.
+//
+// Example:
+//
+// blockB := "...\n...\n..."
+// blockA := "...\n...\n...\n...\n..."
+//
+// // Join 20% from the top
+// str := lipgloss.JoinVertical(0.2, blockA, blockB)
+//
+// // Join on the right edge
+// str := lipgloss.JoinVertical(lipgloss.Right, blockA, blockB)
+func JoinVertical(pos Position, strs ...string) string {
+ if len(strs) == 0 {
+ return ""
+ }
+ if len(strs) == 1 {
+ return strs[0]
+ }
+
+ var (
+ blocks = make([][]string, len(strs))
+ maxWidth int
+ )
+
+ for i := range strs {
+ var w int
+ blocks[i], w = getLines(strs[i])
+ if w > maxWidth {
+ maxWidth = w
+ }
+ }
+
+ var b strings.Builder
+ for i, block := range blocks {
+ for j, line := range block {
+ w := maxWidth - ansi.StringWidth(line)
+
+ switch pos {
+ case Left:
+ b.WriteString(line)
+ b.WriteString(strings.Repeat(" ", w))
+
+ case Right:
+ b.WriteString(strings.Repeat(" ", w))
+ b.WriteString(line)
+
+ default: // Somewhere in the middle
+ if w < 1 {
+ b.WriteString(line)
+ break
+ }
+
+ split := int(math.Round(float64(w) * pos.value()))
+ right := w - split
+ left := w - right
+
+ b.WriteString(strings.Repeat(" ", left))
+ b.WriteString(line)
+ b.WriteString(strings.Repeat(" ", right))
+ }
+
+ // Write a newline as long as we're not on the last line of the
+ // last block.
+ if !(i == len(blocks)-1 && j == len(block)-1) { //nolint:staticcheck
+ b.WriteRune('\n')
+ }
+ }
+ }
+
+ return b.String()
+}
diff --git a/vendor/charm.land/lipgloss/v2/layer.go b/vendor/charm.land/lipgloss/v2/layer.go
new file mode 100644
index 000000000..e30d1ef2a
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/layer.go
@@ -0,0 +1,327 @@
+package lipgloss
+
+import (
+ "fmt"
+ "image"
+ "slices"
+
+ uv "github.com/charmbracelet/ultraviolet"
+)
+
+// Layer represents a visual layer with content and positioning. It's a pure
+// data structure that defines the layer hierarchy without any computation.
+type Layer struct {
+ id string
+ content string
+ width, height int
+ x, y, z int
+ layers []*Layer
+}
+
+// NewLayer creates a new [Layer] with the given content and optional child layers.
+func NewLayer(content string, layers ...*Layer) *Layer {
+ l := &Layer{
+ content: content,
+ }
+ l.AddLayers(layers...)
+ return l
+}
+
+// GetContent returns the content of the Layer.
+func (l *Layer) GetContent() string {
+ return l.content
+}
+
+// Width returns the width of the Layer.
+func (l *Layer) Width() int {
+ return l.width
+}
+
+// Height returns the height of the Layer.
+func (l *Layer) Height() int {
+ return l.height
+}
+
+// GetID returns the ID of the Layer.
+func (l *Layer) GetID() string {
+ return l.id
+}
+
+// ID sets the ID of the Layer.
+func (l *Layer) ID(id string) *Layer {
+ l.id = id
+ return l
+}
+
+// X sets the x-coordinate of the Layer relative to its parent.
+func (l *Layer) X(x int) *Layer {
+ l.x = x
+ return l
+}
+
+// Y sets the y-coordinate of the Layer relative to its parent.
+func (l *Layer) Y(y int) *Layer {
+ l.y = y
+ return l
+}
+
+// Z sets the z-index of the Layer relative to its parent.
+func (l *Layer) Z(z int) *Layer {
+ l.z = z
+ return l
+}
+
+// GetX returns the x-coordinate of the Layer relative to its parent.
+func (l *Layer) GetX() int {
+ return l.x
+}
+
+// GetY returns the y-coordinate of the Layer relative to its parent.
+func (l *Layer) GetY() int {
+ return l.y
+}
+
+// GetZ returns the z-index of the Layer relative to its parent.
+func (l *Layer) GetZ() int {
+ return l.z
+}
+
+// AddLayers adds child layers to the Layer.
+func (l *Layer) AddLayers(layers ...*Layer) *Layer {
+ for i, layer := range layers {
+ if layer == nil {
+ panic(fmt.Sprintf("layer at index %d is nil", i))
+ }
+ l.layers = append(l.layers, layer)
+ }
+ area := l.boundsWithOffset(0, 0)
+ l.width = area.Dx()
+ l.height = area.Dy()
+ return l
+}
+
+// GetLayer returns a descendant layer by its ID, or nil if not found.
+// Layers with empty IDs are skipped.
+func (l *Layer) GetLayer(id string) *Layer {
+ if id == "" {
+ return nil
+ }
+ if l.id == id {
+ return l
+ }
+ for _, child := range l.layers {
+ if found := child.GetLayer(id); found != nil {
+ return found
+ }
+ }
+ return nil
+}
+
+// MaxZ returns the maximum z-index among this layer and all its descendants.
+func (l *Layer) MaxZ() int {
+ maxZ := l.z
+ for _, child := range l.layers {
+ childMaxZ := child.MaxZ()
+ if childMaxZ > maxZ {
+ maxZ = childMaxZ
+ }
+ }
+ return maxZ
+}
+
+// boundsWithOffset calculates bounds with parent offset applied.
+func (l *Layer) boundsWithOffset(parentX, parentY int) image.Rectangle {
+ absX := l.x + parentX
+ absY := l.y + parentY
+
+ width, height := Width(l.content), Height(l.content)
+ bounds := image.Rectangle{
+ Min: image.Pt(absX, absY),
+ Max: image.Pt(absX+width, absY+height),
+ }
+
+ for _, child := range l.layers {
+ bounds = bounds.Union(child.boundsWithOffset(absX, absY))
+ }
+
+ return bounds
+}
+
+var _ uv.Drawable = (*Layer)(nil)
+
+// Draw draws the content of the layer on the screen at the specified area.
+func (l *Layer) Draw(scr uv.Screen, area uv.Rectangle) {
+ content := uv.NewStyledString(l.content)
+ content.Draw(scr, area)
+}
+
+// LayerHit represents the result of a hit test on a [Layer].
+type LayerHit struct {
+ id string
+ layer *Layer
+ bounds image.Rectangle
+}
+
+// Empty returns true if the LayerHit represents no hit.
+func (lh LayerHit) Empty() bool {
+ return lh.layer == nil
+}
+
+// ID returns the ID of the hit Layer.
+func (lh LayerHit) ID() string {
+ return lh.id
+}
+
+// Layer returns the layer that was hit.
+func (lh LayerHit) Layer() *Layer {
+ return lh.layer
+}
+
+// Bounds returns the bounds of the LayerHit.
+func (lh LayerHit) Bounds() image.Rectangle {
+ return lh.bounds
+}
+
+// Compositor manages the composition of layers. It flattens a layer hierarchy
+// once and provides efficient drawing and hit testing operations. All computation
+// related to layers happens in the Compositor.
+type Compositor struct {
+ root *Layer
+ layers []compositeLayer
+ index map[string]*Layer
+ bounds image.Rectangle
+}
+
+// compositeLayer holds a flattened layer with its calculated absolute position and bounds.
+type compositeLayer struct {
+ layer *Layer
+ absX int
+ absY int
+ bounds image.Rectangle
+}
+
+// NewCompositor creates a new Compositor with an internal root layer. Optional
+// layers can be provided which will be added as children of the root. The layer
+// hierarchy is flattened and sorted by z-index for efficient rendering and hit testing.
+func NewCompositor(layers ...*Layer) *Compositor {
+ root := NewLayer("")
+ root.AddLayers(layers...)
+ c := &Compositor{
+ root: root,
+ index: make(map[string]*Layer),
+ }
+ c.flatten()
+ return c
+}
+
+// AddLayers adds layers to the compositor's root and refreshes the internal state.
+func (c *Compositor) AddLayers(layers ...*Layer) *Compositor {
+ c.root.AddLayers(layers...)
+ c.flatten()
+ return c
+}
+
+// flatten builds the internal flattened layer list and calculates overall bounds.
+func (c *Compositor) flatten() {
+ c.layers = nil
+ c.index = make(map[string]*Layer)
+ c.flattenRecursive(c.root, 0, 0)
+
+ // Sort by absolute z-index (lowest to highest for drawing)
+ slices.SortFunc(c.layers, func(a, b compositeLayer) int {
+ return a.layer.z - b.layer.z
+ })
+
+ // Calculate overall bounds
+ if len(c.layers) > 0 {
+ c.bounds = c.layers[0].bounds
+ for i := 1; i < len(c.layers); i++ {
+ c.bounds = c.bounds.Union(c.layers[i].bounds)
+ }
+ }
+}
+
+// flattenRecursive recursively collects all layers with their absolute positions.
+func (c *Compositor) flattenRecursive(layer *Layer, parentX, parentY int) {
+ absX := layer.x + parentX
+ absY := layer.y + parentY
+
+ width, height := Width(layer.content), Height(layer.content)
+ bounds := image.Rectangle{
+ Min: image.Pt(absX, absY),
+ Max: image.Pt(absX+width, absY+height),
+ }
+
+ c.layers = append(c.layers, compositeLayer{
+ layer: layer,
+ absX: absX,
+ absY: absY,
+ bounds: bounds,
+ })
+
+ // Index layer by ID if it has one
+ if layer.id != "" {
+ c.index[layer.id] = layer
+ }
+
+ for _, child := range layer.layers {
+ c.flattenRecursive(child, absX, absY)
+ }
+}
+
+// Bounds returns the overall bounds of all layers in the compositor.
+func (c *Compositor) Bounds() image.Rectangle {
+ return c.bounds
+}
+
+// Draw draws all layers onto the given [uv.Screen] in z-index order.
+func (c *Compositor) Draw(scr uv.Screen, area image.Rectangle) {
+ for _, cl := range c.layers {
+ if cl.bounds.Overlaps(area) {
+ cl.layer.Draw(scr, cl.bounds)
+ }
+ }
+}
+
+// Hit performs a hit test at the given (x, y) coordinates. If a layer is hit,
+// it returns the ID of the top-most layer at that point. Layers with empty IDs
+// are ignored. If no layer is hit, it returns an empty [LayerHit].
+func (c *Compositor) Hit(x, y int) LayerHit {
+ var hit LayerHit
+ pt := image.Pt(x, y)
+ // Check from highest z to lowest (reverse order)
+ for i := len(c.layers) - 1; i >= 0; i-- {
+ cl := c.layers[i]
+ if cl.layer.id != "" && pt.In(cl.bounds) {
+ hit.id = cl.layer.id
+ hit.layer = cl.layer
+ hit.bounds = cl.bounds
+ return hit
+ }
+ }
+ return hit
+}
+
+// GetLayer returns a layer by its ID, or nil if not found.
+// Layers with empty IDs are not indexed and cannot be retrieved.
+func (c *Compositor) GetLayer(id string) *Layer {
+ if id == "" {
+ return nil
+ }
+ return c.index[id]
+}
+
+// Refresh re-flattens the layer hierarchy. Call this after modifying the layer
+// tree structure or positions to update the compositor's internal state.
+func (c *Compositor) Refresh() {
+ c.flatten()
+}
+
+// Render renders the compositor into a styled string. This is a helper
+// function that creates a temporary canvas, draws the compositor onto it, and
+// returns the resulting string.
+func (c *Compositor) Render() string {
+ width, height := c.bounds.Dx(), c.bounds.Dy()
+ canvas := NewCanvas(width, height)
+ return canvas.Compose(c).Render()
+}
diff --git a/vendor/charm.land/lipgloss/v2/lipgloss.go b/vendor/charm.land/lipgloss/v2/lipgloss.go
new file mode 100644
index 000000000..3fb4e6f26
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/lipgloss.go
@@ -0,0 +1,3 @@
+// Package lipgloss provides style definitions for nice terminal layouts. Built
+// with TUIs in mind.
+package lipgloss
diff --git a/vendor/charm.land/lipgloss/v2/position.go b/vendor/charm.land/lipgloss/v2/position.go
new file mode 100644
index 000000000..cea67763f
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/position.go
@@ -0,0 +1,134 @@
+package lipgloss
+
+import (
+ "math"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Position represents a position along a horizontal or vertical axis. It's in
+// situations where an axis is involved, like alignment, joining, placement and
+// so on.
+//
+// A value of 0 represents the start (the left or top) and 1 represents the end
+// (the right or bottom). 0.5 represents the center.
+//
+// There are constants Top, Bottom, Center, Left and Right in this package that
+// can be used to aid readability.
+type Position float64
+
+func (p Position) value() float64 {
+ return math.Min(1, math.Max(0, float64(p)))
+}
+
+// Position aliases.
+const (
+ Top Position = 0.0
+ Bottom Position = 1.0
+ Center Position = 0.5
+ Left Position = 0.0
+ Right Position = 1.0
+)
+
+// Place places a string or text block vertically in an unstyled box of a given
+// width or height.
+func Place(width, height int, hPos, vPos Position, str string, opts ...WhitespaceOption) string {
+ return PlaceVertical(height, vPos, PlaceHorizontal(width, hPos, str, opts...), opts...)
+}
+
+// PlaceHorizontal places a string or text block horizontally in an unstyled
+// block of a given width. If the given width is shorter than the max width of
+// the string (measured by its longest line) this will be a noop.
+func PlaceHorizontal(width int, pos Position, str string, opts ...WhitespaceOption) string {
+ lines, contentWidth := getLines(str)
+ gap := width - contentWidth
+
+ if gap <= 0 {
+ return str
+ }
+
+ ws := newWhitespace(opts...)
+
+ var b strings.Builder
+ for i, l := range lines {
+ // Is this line shorter than the longest line?
+ short := max(0, contentWidth-ansi.StringWidth(l))
+
+ switch pos {
+ case Left:
+ b.WriteString(l)
+ b.WriteString(ws.render(gap + short))
+
+ case Right:
+ b.WriteString(ws.render(gap + short))
+ b.WriteString(l)
+
+ default: // somewhere in the middle
+ totalGap := gap + short
+
+ split := int(math.Round(float64(totalGap) * pos.value()))
+ left := totalGap - split
+ right := totalGap - left
+
+ b.WriteString(ws.render(left))
+ b.WriteString(l)
+ b.WriteString(ws.render(right))
+ }
+
+ if i < len(lines)-1 {
+ b.WriteRune('\n')
+ }
+ }
+
+ return b.String()
+}
+
+// PlaceVertical places a string or text block vertically in an unstyled block
+// of a given height. If the given height is shorter than the height of the
+// string (measured by its newlines) then this will be a noop.
+func PlaceVertical(height int, pos Position, str string, opts ...WhitespaceOption) string {
+ contentHeight := strings.Count(str, "\n") + 1
+ gap := height - contentHeight
+
+ if gap <= 0 {
+ return str
+ }
+
+ ws := newWhitespace(opts...)
+
+ _, width := getLines(str)
+ emptyLine := ws.render(width)
+ b := strings.Builder{}
+
+ switch pos {
+ case Top:
+ b.WriteString(str)
+ b.WriteRune('\n')
+ for i := range gap {
+ b.WriteString(emptyLine)
+ if i < gap-1 {
+ b.WriteRune('\n')
+ }
+ }
+
+ case Bottom:
+ b.WriteString(strings.Repeat(emptyLine+"\n", gap))
+ b.WriteString(str)
+
+ default: // Somewhere in the middle
+ split := int(math.Round(float64(gap) * pos.value()))
+ top := gap - split
+ bottom := gap - top
+
+ b.WriteString(strings.Repeat(emptyLine+"\n", top))
+ b.WriteString(str)
+
+ for range bottom {
+ b.WriteRune('\n')
+ b.WriteString(emptyLine)
+ }
+ }
+
+ return b.String()
+}
diff --git a/vendor/charm.land/lipgloss/v2/query.go b/vendor/charm.land/lipgloss/v2/query.go
new file mode 100644
index 000000000..96cd5b945
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/query.go
@@ -0,0 +1,92 @@
+package lipgloss
+
+import (
+ "fmt"
+ "image/color"
+ "os"
+ "runtime"
+
+ "github.com/charmbracelet/x/term"
+)
+
+func backgroundColor(in term.File, out term.File) (color.Color, error) {
+ state, err := term.MakeRaw(in.Fd())
+ if err != nil {
+ return nil, fmt.Errorf("error setting raw state to detect background color: %w", err)
+ }
+
+ defer term.Restore(in.Fd(), state) //nolint:errcheck
+
+ bg, err := queryBackgroundColor(in, out)
+ if err != nil {
+ return nil, err
+ }
+
+ return bg, nil
+}
+
+// BackgroundColor queries the terminal's background color. Typically, you'll
+// want to query against stdin and either stdout or stderr, depending on what
+// you're writing to.
+//
+// This function is intended for standalone Lip Gloss use only. If you're using
+// Bubble Tea, listen for tea.BackgroundColorMsg in your update function.
+func BackgroundColor(in term.File, out term.File) (bg color.Color, err error) {
+ if runtime.GOOS == "windows" { //nolint:nestif
+ // On Windows, when the input/output is redirected or piped, we need to
+ // open the console explicitly.
+ // See https://learn.microsoft.com/en-us/windows/console/getstdhandle#remarks
+ if !term.IsTerminal(in.Fd()) {
+ f, err := os.OpenFile("CONIN$", os.O_RDWR, 0o644) //nolint:gosec
+ if err != nil {
+ return nil, fmt.Errorf("error opening CONIN$: %w", err)
+ }
+ in = f
+ }
+ if !term.IsTerminal(out.Fd()) {
+ f, err := os.OpenFile("CONOUT$", os.O_RDWR, 0o644) //nolint:gosec
+ if err != nil {
+ return nil, fmt.Errorf("error opening CONOUT$: %w", err)
+ }
+ out = f
+ }
+ return backgroundColor(in, out)
+ }
+
+ // NOTE: On Unix, one of the given files must be a tty.
+ if !term.IsTerminal(in.Fd()) || !term.IsTerminal(out.Fd()) {
+ return nil, fmt.Errorf("input/output is not a terminal")
+ }
+ for _, f := range []term.File{in, out} {
+ if bg, err = backgroundColor(f, f); err == nil {
+ return bg, nil
+ }
+ }
+
+ return bg, err
+}
+
+// HasDarkBackground detects whether the terminal has a light or dark
+// background.
+//
+// Typically, you'll want to query against stdin and either stdout or stderr
+// depending on what you're writing to.
+//
+// hasDarkBG := HasDarkBackground(os.Stdin, os.Stdout)
+// lightDark := LightDark(hasDarkBG)
+// myHotColor := lightDark("#ff0000", "#0000ff")
+//
+// This is intended for use in standalone Lip Gloss only. In Bubble Tea, listen
+// for tea.BackgroundColorMsg in your Update function.
+//
+// case tea.BackgroundColorMsg:
+// hasDarkBackground = msg.IsDark()
+//
+// By default, this function will return true if it encounters an error.
+func HasDarkBackground(in term.File, out term.File) bool {
+ bg, err := BackgroundColor(in, out)
+ if err != nil || bg == nil {
+ return true
+ }
+ return isDarkColor(bg)
+}
diff --git a/vendor/charm.land/lipgloss/v2/ranges.go b/vendor/charm.land/lipgloss/v2/ranges.go
new file mode 100644
index 000000000..bb209f0ea
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/ranges.go
@@ -0,0 +1,48 @@
+package lipgloss
+
+import (
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// StyleRanges applying styling to ranges in a string. Existing styles will be
+// taken into account. Ranges should not overlap.
+func StyleRanges(s string, ranges ...Range) string {
+ if len(ranges) == 0 {
+ return s
+ }
+
+ var buf strings.Builder
+ lastIdx := 0
+ stripped := ansi.Strip(s)
+
+ // Use Truncate and TruncateLeft to style match.MatchedIndexes without
+ // losing the original option style:
+ for _, rng := range ranges {
+ // Add the text before this match
+ if rng.Start > lastIdx {
+ buf.WriteString(ansi.Cut(s, lastIdx, rng.Start))
+ }
+ // Add the matched range with its highlight
+ buf.WriteString(rng.Style.Render(ansi.Cut(stripped, rng.Start, rng.End)))
+ lastIdx = rng.End
+ }
+
+ // Add any remaining text after the last match
+ buf.WriteString(ansi.TruncateLeft(s, lastIdx, ""))
+
+ return buf.String()
+}
+
+// NewRange returns a range and style that can be used with [StyleRanges].
+func NewRange(start, end int, style Style) Range {
+ return Range{start, end, style}
+}
+
+// Range is a range of text and associated styling to be used with
+// [StyleRanges].
+type Range struct {
+ Start, End int
+ Style Style
+}
diff --git a/vendor/charm.land/lipgloss/v2/runes.go b/vendor/charm.land/lipgloss/v2/runes.go
new file mode 100644
index 000000000..7a49e326c
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/runes.go
@@ -0,0 +1,43 @@
+package lipgloss
+
+import (
+ "strings"
+)
+
+// StyleRunes apply a given style to runes at the given indices in the string.
+// Note that you must provide styling options for both matched and unmatched
+// runes. Indices out of bounds will be ignored.
+func StyleRunes(str string, indices []int, matched, unmatched Style) string {
+ // Convert slice of indices to a map for easier lookups
+ m := make(map[int]struct{})
+ for _, i := range indices {
+ m[i] = struct{}{}
+ }
+
+ var (
+ out strings.Builder
+ group strings.Builder
+ style Style
+ runes = []rune(str)
+ )
+
+ for i, r := range runes {
+ group.WriteRune(r)
+
+ _, matches := m[i]
+ _, nextMatches := m[i+1]
+
+ if matches != nextMatches || i == len(runes)-1 {
+ // Flush
+ if matches {
+ style = matched
+ } else {
+ style = unmatched
+ }
+ out.WriteString(style.Render(group.String()))
+ group.Reset()
+ }
+ }
+
+ return out.String()
+}
diff --git a/vendor/charm.land/lipgloss/v2/set.go b/vendor/charm.land/lipgloss/v2/set.go
new file mode 100644
index 000000000..f10b4538a
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/set.go
@@ -0,0 +1,932 @@
+package lipgloss
+
+import (
+ "image/color"
+ "strings"
+)
+
+// Set a value on the underlying rules map.
+func (s *Style) set(key propKey, value any) {
+ // We don't allow negative integers on any of our other values, so just keep
+ // them at zero or above. We could use uints instead, but the
+ // conversions are a little tedious, so we're sticking with ints for
+ // sake of usability.
+ switch key {
+ case foregroundKey:
+ s.fgColor = colorOrNil(value)
+ case backgroundKey:
+ s.bgColor = colorOrNil(value)
+ case underlineColorKey:
+ s.ulColor = colorOrNil(value)
+ case underlineKey:
+ s.ul = value.(Underline)
+ case widthKey:
+ s.width = max(0, value.(int))
+ case heightKey:
+ s.height = max(0, value.(int))
+ case alignHorizontalKey:
+ s.alignHorizontal = value.(Position)
+ case alignVerticalKey:
+ s.alignVertical = value.(Position)
+ case paddingTopKey:
+ s.paddingTop = max(0, value.(int))
+ case paddingRightKey:
+ s.paddingRight = max(0, value.(int))
+ case paddingBottomKey:
+ s.paddingBottom = max(0, value.(int))
+ case paddingLeftKey:
+ s.paddingLeft = max(0, value.(int))
+ case paddingCharKey:
+ s.paddingChar = value.(rune)
+ case marginTopKey:
+ s.marginTop = max(0, value.(int))
+ case marginRightKey:
+ s.marginRight = max(0, value.(int))
+ case marginBottomKey:
+ s.marginBottom = max(0, value.(int))
+ case marginLeftKey:
+ s.marginLeft = max(0, value.(int))
+ case marginBackgroundKey:
+ s.marginBgColor = colorOrNil(value)
+ case marginCharKey:
+ s.marginChar = value.(rune)
+ case borderStyleKey:
+ s.borderStyle = value.(Border)
+ case borderTopForegroundKey:
+ s.borderTopFgColor = colorOrNil(value)
+ case borderRightForegroundKey:
+ s.borderRightFgColor = colorOrNil(value)
+ case borderBottomForegroundKey:
+ s.borderBottomFgColor = colorOrNil(value)
+ case borderLeftForegroundKey:
+ s.borderLeftFgColor = colorOrNil(value)
+ case borderForegroundBlendKey:
+ s.borderBlendFgColor = value.([]color.Color)
+ case borderForegroundBlendOffsetKey:
+ s.borderForegroundBlendOffset = value.(int)
+ case borderTopBackgroundKey:
+ s.borderTopBgColor = colorOrNil(value)
+ case borderRightBackgroundKey:
+ s.borderRightBgColor = colorOrNil(value)
+ case borderBottomBackgroundKey:
+ s.borderBottomBgColor = colorOrNil(value)
+ case borderLeftBackgroundKey:
+ s.borderLeftBgColor = colorOrNil(value)
+ case maxWidthKey:
+ s.maxWidth = max(0, value.(int))
+ case maxHeightKey:
+ s.maxHeight = max(0, value.(int))
+ case tabWidthKey:
+ // TabWidth is the only property that may have a negative value (and
+ // that negative value can be no less than -1).
+ s.tabWidth = value.(int)
+ case transformKey:
+ s.transform = value.(func(string) string)
+ case linkKey:
+ s.link = value.(string)
+ case linkParamsKey:
+ s.linkParams = value.(string)
+ default:
+ if v, ok := value.(bool); ok { //nolint:nestif
+ if v {
+ s.attrs |= int(key)
+ } else {
+ s.attrs &^= int(key)
+ }
+ } else if attrs, ok := value.(int); ok {
+ // bool attrs
+ if attrs&int(key) != 0 {
+ s.attrs |= int(key)
+ } else {
+ s.attrs &^= int(key)
+ }
+ }
+ }
+
+ // Set the prop on
+ s.props = s.props.set(key)
+}
+
+// setFrom sets the property from another style.
+func (s *Style) setFrom(key propKey, i Style) {
+ switch key {
+ case foregroundKey:
+ s.set(foregroundKey, i.fgColor)
+ case backgroundKey:
+ s.set(backgroundKey, i.bgColor)
+ case underlineColorKey:
+ s.set(underlineColorKey, i.ulColor)
+ case underlineKey:
+ s.set(underlineKey, i.ul)
+ case widthKey:
+ s.set(widthKey, i.width)
+ case heightKey:
+ s.set(heightKey, i.height)
+ case alignHorizontalKey:
+ s.set(alignHorizontalKey, i.alignHorizontal)
+ case alignVerticalKey:
+ s.set(alignVerticalKey, i.alignVertical)
+ case paddingTopKey:
+ s.set(paddingTopKey, i.paddingTop)
+ case paddingRightKey:
+ s.set(paddingRightKey, i.paddingRight)
+ case paddingBottomKey:
+ s.set(paddingBottomKey, i.paddingBottom)
+ case paddingLeftKey:
+ s.set(paddingLeftKey, i.paddingLeft)
+ case paddingCharKey:
+ s.set(paddingCharKey, i.paddingChar)
+ case marginTopKey:
+ s.set(marginTopKey, i.marginTop)
+ case marginRightKey:
+ s.set(marginRightKey, i.marginRight)
+ case marginBottomKey:
+ s.set(marginBottomKey, i.marginBottom)
+ case marginLeftKey:
+ s.set(marginLeftKey, i.marginLeft)
+ case marginBackgroundKey:
+ s.set(marginBackgroundKey, i.marginBgColor)
+ case marginCharKey:
+ s.set(marginCharKey, i.marginChar)
+ case borderStyleKey:
+ s.set(borderStyleKey, i.borderStyle)
+ case borderTopForegroundKey:
+ s.set(borderTopForegroundKey, i.borderTopFgColor)
+ case borderRightForegroundKey:
+ s.set(borderRightForegroundKey, i.borderRightFgColor)
+ case borderBottomForegroundKey:
+ s.set(borderBottomForegroundKey, i.borderBottomFgColor)
+ case borderLeftForegroundKey:
+ s.set(borderLeftForegroundKey, i.borderLeftFgColor)
+ case borderForegroundBlendKey:
+ s.set(borderForegroundBlendKey, i.borderBlendFgColor)
+ case borderForegroundBlendOffsetKey:
+ s.set(borderForegroundBlendOffsetKey, i.borderForegroundBlendOffset)
+ case borderTopBackgroundKey:
+ s.set(borderTopBackgroundKey, i.borderTopBgColor)
+ case borderRightBackgroundKey:
+ s.set(borderRightBackgroundKey, i.borderRightBgColor)
+ case borderBottomBackgroundKey:
+ s.set(borderBottomBackgroundKey, i.borderBottomBgColor)
+ case borderLeftBackgroundKey:
+ s.set(borderLeftBackgroundKey, i.borderLeftBgColor)
+ case maxWidthKey:
+ s.set(maxWidthKey, i.maxWidth)
+ case maxHeightKey:
+ s.set(maxHeightKey, i.maxHeight)
+ case tabWidthKey:
+ s.set(tabWidthKey, i.tabWidth)
+ case transformKey:
+ s.set(transformKey, i.transform)
+ default:
+ // Set attributes for set bool properties
+ s.set(key, i.attrs)
+ }
+}
+
+func colorOrNil(c any) color.Color {
+ if c, ok := c.(color.Color); ok {
+ return c
+ }
+ return nil
+}
+
+// Bold sets a bold formatting rule.
+func (s Style) Bold(v bool) Style {
+ s.set(boldKey, v)
+ return s
+}
+
+// Italic sets an italic formatting rule. In some terminal emulators this will
+// render with "reverse" coloring if not italic font variant is available.
+func (s Style) Italic(v bool) Style {
+ s.set(italicKey, v)
+ return s
+}
+
+// Underline sets an underline rule. By default, underlines will not be drawn on
+// whitespace like margins and padding. To change this behavior set
+// [Style.UnderlineSpaces].
+func (s Style) Underline(v bool) Style {
+ if v {
+ return s.UnderlineStyle(UnderlineSingle)
+ }
+ return s.UnderlineStyle(UnderlineNone)
+}
+
+// UnderlineStyle sets the underline style. This can be used to set the underline
+// to be a single, double, curly, dotted, or dashed line.
+//
+// Note that not all terminal emulators support underline styles. If a style is
+// not supported, it will typically fall back to a single underline but this is
+// not guaranteed. This depends on the terminal emulator being used.
+func (s Style) UnderlineStyle(u Underline) Style {
+ s.set(underlineKey, u)
+ return s
+}
+
+// UnderlineColor sets the color of the underline. By default, the underline
+// will be the same color as the foreground.
+//
+// Note that not all terminal emulators support colored underlines. If color is
+// not supported, it might produce unexpected results. This depends on the
+// terminal emulator being used.
+func (s Style) UnderlineColor(c color.Color) Style {
+ s.set(underlineColorKey, c)
+ return s
+}
+
+// Strikethrough sets a strikethrough rule. By default, strikes will not be
+// drawn on whitespace like margins and padding. To change this behavior set
+// StrikethroughSpaces.
+func (s Style) Strikethrough(v bool) Style {
+ s.set(strikethroughKey, v)
+ return s
+}
+
+// Reverse sets a rule for inverting foreground and background colors.
+func (s Style) Reverse(v bool) Style {
+ s.set(reverseKey, v)
+ return s
+}
+
+// Blink sets a rule for blinking foreground text.
+func (s Style) Blink(v bool) Style {
+ s.set(blinkKey, v)
+ return s
+}
+
+// Faint sets a rule for rendering the foreground color in a dimmer shade.
+func (s Style) Faint(v bool) Style {
+ s.set(faintKey, v)
+ return s
+}
+
+// Foreground sets a foreground color.
+//
+// // Sets the foreground to blue
+// s := lipgloss.NewStyle().Foreground(lipgloss.Color("#0000ff"))
+//
+// // Removes the foreground color
+// s.Foreground(lipgloss.NoColor)
+func (s Style) Foreground(c color.Color) Style {
+ s.set(foregroundKey, c)
+ return s
+}
+
+// Background sets a background color.
+func (s Style) Background(c color.Color) Style {
+ s.set(backgroundKey, c)
+ return s
+}
+
+// Width sets the width of the block before applying margins. This means your
+// styled content will exactly equal the size set here. Text will wrap based on
+// Padding and Borders set on the style.
+func (s Style) Width(i int) Style {
+ s.set(widthKey, i)
+ return s
+}
+
+// Height sets the height of the block before applying margins. If the height of
+// the text block is less than this value after applying padding (or not), the
+// block will be set to this height.
+func (s Style) Height(i int) Style {
+ s.set(heightKey, i)
+ return s
+}
+
+// Align is a shorthand method for setting horizontal and vertical alignment.
+//
+// With one argument, the position value is applied to the horizontal alignment.
+//
+// With two arguments, the value is applied to the horizontal and vertical
+// alignments, in that order.
+func (s Style) Align(p ...Position) Style {
+ if len(p) > 0 {
+ s.set(alignHorizontalKey, p[0])
+ }
+ if len(p) > 1 {
+ s.set(alignVerticalKey, p[1])
+ }
+ return s
+}
+
+// AlignHorizontal sets a horizontal text alignment rule.
+func (s Style) AlignHorizontal(p Position) Style {
+ s.set(alignHorizontalKey, p)
+ return s
+}
+
+// AlignVertical sets a vertical text alignment rule.
+func (s Style) AlignVertical(p Position) Style {
+ s.set(alignVerticalKey, p)
+ return s
+}
+
+// Padding is a shorthand method for setting padding on all sides at once.
+//
+// With one argument, the value is applied to all sides.
+//
+// With two arguments, the value is applied to the vertical and horizontal
+// sides, in that order.
+//
+// With three arguments, the value is applied to the top side, the horizontal
+// sides, and the bottom side, in that order.
+//
+// With four arguments, the value is applied clockwise starting from the top
+// side, followed by the right side, then the bottom, and finally the left.
+//
+// With more than four arguments no padding will be added.
+func (s Style) Padding(i ...int) Style {
+ top, right, bottom, left, ok := whichSidesInt(i...)
+ if !ok {
+ return s
+ }
+
+ s.set(paddingTopKey, top)
+ s.set(paddingRightKey, right)
+ s.set(paddingBottomKey, bottom)
+ s.set(paddingLeftKey, left)
+ return s
+}
+
+// PaddingLeft adds padding on the left.
+func (s Style) PaddingLeft(i int) Style {
+ s.set(paddingLeftKey, i)
+ return s
+}
+
+// PaddingRight adds padding on the right.
+func (s Style) PaddingRight(i int) Style {
+ s.set(paddingRightKey, i)
+ return s
+}
+
+// PaddingTop adds padding to the top of the block.
+func (s Style) PaddingTop(i int) Style {
+ s.set(paddingTopKey, i)
+ return s
+}
+
+// PaddingBottom adds padding to the bottom of the block.
+func (s Style) PaddingBottom(i int) Style {
+ s.set(paddingBottomKey, i)
+ return s
+}
+
+// PaddingChar sets the character used for padding. This is useful for
+// rendering blocks with a specific character, such as a space or a dot.
+// Example of using [NBSP] as padding to prevent line breaks:
+//
+// ```go
+// s := lipgloss.NewStyle().PaddingChar(lipgloss.NBSP)
+// ```
+func (s Style) PaddingChar(r rune) Style {
+ s.set(paddingCharKey, r)
+ return s
+}
+
+// ColorWhitespace determines whether or not the background color should be
+// applied to the padding. This is true by default as it's more than likely the
+// desired and expected behavior, but it can be disabled for certain graphic
+// effects.
+//
+// Deprecated: Just use margins and padding.
+func (s Style) ColorWhitespace(v bool) Style {
+ s.set(colorWhitespaceKey, v)
+ return s
+}
+
+// Margin is a shorthand method for setting margins on all sides at once.
+//
+// With one argument, the value is applied to all sides.
+//
+// With two arguments, the value is applied to the vertical and horizontal
+// sides, in that order.
+//
+// With three arguments, the value is applied to the top side, the horizontal
+// sides, and the bottom side, in that order.
+//
+// With four arguments, the value is applied clockwise starting from the top
+// side, followed by the right side, then the bottom, and finally the left.
+//
+// With more than four arguments no margin will be added.
+func (s Style) Margin(i ...int) Style {
+ top, right, bottom, left, ok := whichSidesInt(i...)
+ if !ok {
+ return s
+ }
+
+ s.set(marginTopKey, top)
+ s.set(marginRightKey, right)
+ s.set(marginBottomKey, bottom)
+ s.set(marginLeftKey, left)
+ return s
+}
+
+// MarginLeft sets the value of the left margin.
+func (s Style) MarginLeft(i int) Style {
+ s.set(marginLeftKey, i)
+ return s
+}
+
+// MarginRight sets the value of the right margin.
+func (s Style) MarginRight(i int) Style {
+ s.set(marginRightKey, i)
+ return s
+}
+
+// MarginTop sets the value of the top margin.
+func (s Style) MarginTop(i int) Style {
+ s.set(marginTopKey, i)
+ return s
+}
+
+// MarginBottom sets the value of the bottom margin.
+func (s Style) MarginBottom(i int) Style {
+ s.set(marginBottomKey, i)
+ return s
+}
+
+// MarginBackground sets the background color of the margin. Note that this is
+// also set when inheriting from a style with a background color. In that case
+// the background color on that style will set the margin color on this style.
+func (s Style) MarginBackground(c color.Color) Style {
+ s.set(marginBackgroundKey, c)
+ return s
+}
+
+// MarginChar sets the character used for the margin. This is useful for
+// rendering blocks with a specific character, such as a space or a dot.
+func (s Style) MarginChar(r rune) Style {
+ s.set(marginCharKey, r)
+ return s
+}
+
+// Border is shorthand for setting the border style and which sides should
+// have a border at once. The variadic argument sides works as follows:
+//
+// With one value, the value is applied to all sides.
+//
+// With two values, the values are applied to the vertical and horizontal
+// sides, in that order.
+//
+// With three values, the values are applied to the top side, the horizontal
+// sides, and the bottom side, in that order.
+//
+// With four values, the values are applied clockwise starting from the top
+// side, followed by the right side, then the bottom, and finally the left.
+//
+// With more than four arguments the border will be applied to all sides.
+//
+// Examples:
+//
+// // Applies borders to the top and bottom only
+// lipgloss.NewStyle().Border(lipgloss.NormalBorder(), true, false)
+//
+// // Applies rounded borders to the right and bottom only
+// lipgloss.NewStyle().Border(lipgloss.RoundedBorder(), false, true, true, false)
+func (s Style) Border(b Border, sides ...bool) Style {
+ s.set(borderStyleKey, b)
+
+ top, right, bottom, left, ok := whichSidesBool(sides...)
+ if !ok {
+ top = true
+ right = true
+ bottom = true
+ left = true
+ }
+
+ s.set(borderTopKey, top)
+ s.set(borderRightKey, right)
+ s.set(borderBottomKey, bottom)
+ s.set(borderLeftKey, left)
+
+ return s
+}
+
+// BorderStyle defines the Border on a style. A Border contains a series of
+// definitions for the sides and corners of a border.
+//
+// Note that if border visibility has not been set for any sides when setting
+// the border style, the border will be enabled for all sides during rendering.
+//
+// You can define border characters as you'd like, though several default
+// styles are included: NormalBorder(), RoundedBorder(), BlockBorder(),
+// OuterHalfBlockBorder(), InnerHalfBlockBorder(), ThickBorder(),
+// and DoubleBorder().
+//
+// Example:
+//
+// lipgloss.NewStyle().BorderStyle(lipgloss.ThickBorder())
+func (s Style) BorderStyle(b Border) Style {
+ s.set(borderStyleKey, b)
+ return s
+}
+
+// BorderTop determines whether or not to draw a top border.
+func (s Style) BorderTop(v bool) Style {
+ s.set(borderTopKey, v)
+ return s
+}
+
+// BorderRight determines whether or not to draw a right border.
+func (s Style) BorderRight(v bool) Style {
+ s.set(borderRightKey, v)
+ return s
+}
+
+// BorderBottom determines whether or not to draw a bottom border.
+func (s Style) BorderBottom(v bool) Style {
+ s.set(borderBottomKey, v)
+ return s
+}
+
+// BorderLeft determines whether or not to draw a left border.
+func (s Style) BorderLeft(v bool) Style {
+ s.set(borderLeftKey, v)
+ return s
+}
+
+// BorderForeground is a shorthand function for setting all of the
+// foreground colors of the borders at once. The arguments work as follows:
+//
+// With one argument, the argument is applied to all sides.
+//
+// With two arguments, the arguments are applied to the vertical and horizontal
+// sides, in that order.
+//
+// With three arguments, the arguments are applied to the top side, the
+// horizontal sides, and the bottom side, in that order.
+//
+// With four arguments, the arguments are applied clockwise starting from the
+// top side, followed by the right side, then the bottom, and finally the left.
+//
+// With more than four arguments nothing will be set.
+func (s Style) BorderForeground(c ...color.Color) Style {
+ if len(c) == 0 {
+ return s
+ }
+
+ top, right, bottom, left, ok := whichSidesColor(c...)
+ if !ok {
+ return s
+ }
+
+ s.set(borderTopForegroundKey, top)
+ s.set(borderRightForegroundKey, right)
+ s.set(borderBottomForegroundKey, bottom)
+ s.set(borderLeftForegroundKey, left)
+
+ return s
+}
+
+// BorderTopForeground set the foreground color for the top of the border.
+func (s Style) BorderTopForeground(c color.Color) Style {
+ s.set(borderTopForegroundKey, c)
+ return s
+}
+
+// BorderRightForeground sets the foreground color for the right side of the
+// border.
+func (s Style) BorderRightForeground(c color.Color) Style {
+ s.set(borderRightForegroundKey, c)
+ return s
+}
+
+// BorderBottomForeground sets the foreground color for the bottom of the
+// border.
+func (s Style) BorderBottomForeground(c color.Color) Style {
+ s.set(borderBottomForegroundKey, c)
+ return s
+}
+
+// BorderLeftForeground sets the foreground color for the left side of the
+// border.
+func (s Style) BorderLeftForeground(c color.Color) Style {
+ s.set(borderLeftForegroundKey, c)
+ return s
+}
+
+// BorderForegroundBlend sets the foreground colors for the border blend. At least
+// 2 colors are required to use blending, otherwise this will no-op with 0 colors,
+// and pass to BorderForeground with 1 color. This will override all other border
+// foreground colors when used.
+//
+// When providing colors, in most cases (e.g. when all border sides are enabled),
+// you will want to provide a wrapping-set of colors, so the start and end color
+// are either the same, or very similar. For example:
+//
+// lipgloss.NewStyle().BorderForegroundBlend(
+// lipgloss.Color("#00FA68"),
+// lipgloss.Color("#9900FF"),
+// lipgloss.Color("#ED5353"),
+// lipgloss.Color("#9900FF"),
+// lipgloss.Color("#00FA68"),
+// )
+func (s Style) BorderForegroundBlend(c ...color.Color) Style {
+ if len(c) == 0 {
+ return s
+ }
+
+ // Insufficient colors to use blending, pass to BorderForeground.
+ if len(c) == 1 {
+ return s.BorderForeground(c...)
+ }
+
+ s.set(borderForegroundBlendKey, c)
+ return s
+}
+
+// BorderForegroundBlendOffset sets the border blend offset cells, starting from
+// the top left corner. Value can be positive or negative, and does not need to
+// equal the dimensions of the border region. Direction (when positive) is as
+// follows ("o" is starting point):
+//
+// o -------->
+// ┌──────────┐
+// ^ │ │ |
+// | │ │ |
+// | │ │ |
+// | │ │ v
+// └──────────┘
+// <---------
+func (s Style) BorderForegroundBlendOffset(v int) Style {
+ s.set(borderForegroundBlendOffsetKey, v)
+ return s
+}
+
+// BorderBackground is a shorthand function for setting all of the
+// background colors of the borders at once. The arguments work as follows:
+//
+// With one argument, the argument is applied to all sides.
+//
+// With two arguments, the arguments are applied to the vertical and horizontal
+// sides, in that order.
+//
+// With three arguments, the arguments are applied to the top side, the
+// horizontal sides, and the bottom side, in that order.
+//
+// With four arguments, the arguments are applied clockwise starting from the
+// top side, followed by the right side, then the bottom, and finally the left.
+//
+// With more than four arguments nothing will be set.
+func (s Style) BorderBackground(c ...color.Color) Style {
+ if len(c) == 0 {
+ return s
+ }
+
+ top, right, bottom, left, ok := whichSidesColor(c...)
+ if !ok {
+ return s
+ }
+
+ s.set(borderTopBackgroundKey, top)
+ s.set(borderRightBackgroundKey, right)
+ s.set(borderBottomBackgroundKey, bottom)
+ s.set(borderLeftBackgroundKey, left)
+
+ return s
+}
+
+// BorderTopBackground sets the background color of the top of the border.
+func (s Style) BorderTopBackground(c color.Color) Style {
+ s.set(borderTopBackgroundKey, c)
+ return s
+}
+
+// BorderRightBackground sets the background color of right side the border.
+func (s Style) BorderRightBackground(c color.Color) Style {
+ s.set(borderRightBackgroundKey, c)
+ return s
+}
+
+// BorderBottomBackground sets the background color of the bottom of the
+// border.
+func (s Style) BorderBottomBackground(c color.Color) Style {
+ s.set(borderBottomBackgroundKey, c)
+ return s
+}
+
+// BorderLeftBackground set the background color of the left side of the
+// border.
+func (s Style) BorderLeftBackground(c color.Color) Style {
+ s.set(borderLeftBackgroundKey, c)
+ return s
+}
+
+// Inline makes rendering output one line and disables the rendering of
+// margins, padding and borders. This is useful when you need a style to apply
+// only to font rendering and don't want it to change any physical dimensions.
+// It works well with Style.MaxWidth.
+//
+// Because this in intended to be used at the time of render, this method will
+// not mutate the style and instead return a copy.
+//
+// Example:
+//
+// var userInput string = "..."
+// var userStyle = text.Style{ /* ... */ }
+// fmt.Println(userStyle.Inline(true).Render(userInput))
+func (s Style) Inline(v bool) Style {
+ o := s // copy
+ o.set(inlineKey, v)
+ return o
+}
+
+// MaxWidth applies a max width to a given style. This is useful in enforcing
+// a certain width at render time, particularly with arbitrary strings and
+// styles.
+//
+// Because this in intended to be used at the time of render, this method will
+// not mutate the style and instead return a copy.
+//
+// Example:
+//
+// var userInput string = "..."
+// var userStyle = text.Style{ /* ... */ }
+// fmt.Println(userStyle.MaxWidth(16).Render(userInput))
+func (s Style) MaxWidth(n int) Style {
+ o := s // copy
+ o.set(maxWidthKey, n)
+ return o
+}
+
+// MaxHeight applies a max height to a given style. This is useful in enforcing
+// a certain height at render time, particularly with arbitrary strings and
+// styles.
+//
+// Because this in intended to be used at the time of render, this method will
+// not mutate the style and instead returns a copy.
+func (s Style) MaxHeight(n int) Style {
+ o := s // copy
+ o.set(maxHeightKey, n)
+ return o
+}
+
+// NoTabConversion can be passed to [Style.TabWidth] to disable the replacement
+// of tabs with spaces at render time.
+const NoTabConversion = -1
+
+// TabWidth sets the number of spaces that a tab (/t) should be rendered as.
+// When set to 0, tabs will be removed. To disable the replacement of tabs with
+// spaces entirely, set this to [NoTabConversion].
+//
+// By default, tabs will be replaced with 4 spaces.
+func (s Style) TabWidth(n int) Style {
+ if n <= -1 {
+ n = -1
+ }
+ s.set(tabWidthKey, n)
+ return s
+}
+
+// UnderlineSpaces determines whether to underline spaces between words. By
+// default, this is true. Spaces can also be underlined without underlining the
+// text itself.
+func (s Style) UnderlineSpaces(v bool) Style {
+ s.set(underlineSpacesKey, v)
+ return s
+}
+
+// StrikethroughSpaces determines whether to apply strikethroughs to spaces
+// between words. By default, this is true. Spaces can also be struck without
+// underlining the text itself.
+func (s Style) StrikethroughSpaces(v bool) Style {
+ s.set(strikethroughSpacesKey, v)
+ return s
+}
+
+// Transform applies a given function to a string at render time, allowing for
+// the string being rendered to be manipuated.
+//
+// Example:
+//
+// s := NewStyle().Transform(strings.ToUpper)
+// fmt.Println(s.Render("raow!") // "RAOW!"
+func (s Style) Transform(fn func(string) string) Style {
+ s.set(transformKey, fn)
+ return s
+}
+
+// Hyperlink sets a hyperlink on a style. This is useful for rendering text that
+// can be clicked on in a terminal emulator that supports hyperlinks.
+//
+// Example:
+//
+// s := lipgloss.NewStyle().Hyperlink("https://charm.sh")
+// s := lipgloss.NewStyle().Hyperlink("https://charm.sh", "id=1")
+func (s Style) Hyperlink(link string, params ...string) Style {
+ s.set(linkKey, link)
+ if len(params) > 0 {
+ s.set(linkParamsKey, strings.Join(params, ":"))
+ }
+ return s
+}
+
+// whichSidesInt is a helper method for setting values on sides of a block based
+// on the number of arguments. It follows the CSS shorthand rules for blocks
+// like margin, padding. and borders. Here are how the rules work:
+//
+// 0 args: do nothing
+// 1 arg: all sides
+// 2 args: top -> bottom
+// 3 args: top -> horizontal -> bottom
+// 4 args: top -> right -> bottom -> left
+// 5+ args: do nothing.
+func whichSidesInt(i ...int) (top, right, bottom, left int, ok bool) {
+ switch len(i) {
+ case 1:
+ top = i[0]
+ bottom = i[0]
+ left = i[0]
+ right = i[0]
+ ok = true
+ case 2: //nolint:mnd
+ top = i[0]
+ bottom = i[0]
+ left = i[1]
+ right = i[1]
+ ok = true
+ case 3: //nolint:mnd
+ top = i[0]
+ left = i[1]
+ right = i[1]
+ bottom = i[2]
+ ok = true
+ case 4: //nolint:mnd
+ top = i[0]
+ right = i[1]
+ bottom = i[2]
+ left = i[3]
+ ok = true
+ }
+ return top, right, bottom, left, ok
+}
+
+// whichSidesBool is like whichSidesInt, except it operates on a series of
+// boolean values. See the comment on whichSidesInt for details on how this
+// works.
+func whichSidesBool(i ...bool) (top, right, bottom, left bool, ok bool) {
+ switch len(i) {
+ case 1:
+ top = i[0]
+ bottom = i[0]
+ left = i[0]
+ right = i[0]
+ ok = true
+ case 2: //nolint:mnd
+ top = i[0]
+ bottom = i[0]
+ left = i[1]
+ right = i[1]
+ ok = true
+ case 3: //nolint:mnd
+ top = i[0]
+ left = i[1]
+ right = i[1]
+ bottom = i[2]
+ ok = true
+ case 4: //nolint:mnd
+ top = i[0]
+ right = i[1]
+ bottom = i[2]
+ left = i[3]
+ ok = true
+ }
+ return top, right, bottom, left, ok
+}
+
+// whichSidesColor is like whichSides, except it operates on a series of
+// boolean values. See the comment on whichSidesInt for details on how this
+// works.
+func whichSidesColor(i ...color.Color) (top, right, bottom, left color.Color, ok bool) {
+ switch len(i) {
+ case 1:
+ top = i[0]
+ bottom = i[0]
+ left = i[0]
+ right = i[0]
+ ok = true
+ case 2: //nolint:mnd
+ top = i[0]
+ bottom = i[0]
+ left = i[1]
+ right = i[1]
+ ok = true
+ case 3: //nolint:mnd
+ top = i[0]
+ left = i[1]
+ right = i[1]
+ bottom = i[2]
+ ok = true
+ case 4: //nolint:mnd
+ top = i[0]
+ right = i[1]
+ bottom = i[2]
+ left = i[3]
+ ok = true
+ }
+ return top, right, bottom, left, ok
+}
diff --git a/vendor/charm.land/lipgloss/v2/size.go b/vendor/charm.land/lipgloss/v2/size.go
new file mode 100644
index 000000000..e0384d035
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/size.go
@@ -0,0 +1,40 @@
+package lipgloss
+
+import (
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Width returns the cell width of characters in the string. ANSI sequences are
+// ignored and characters wider than one cell (such as Chinese characters and
+// emojis) are appropriately measured.
+//
+// You should use this instead of len(string) or len([]rune(string) as neither
+// will give you accurate results.
+func Width(str string) (width int) {
+ for l := range strings.SplitSeq(str, "\n") {
+ w := ansi.StringWidth(l)
+ if w > width {
+ width = w
+ }
+ }
+
+ return width
+}
+
+// Height returns height of a string in cells. This is done simply by
+// counting \n characters. If your output has \r\n, that sequence will be
+// replaced with a \n in [Style.Render].
+func Height(str string) int {
+ return strings.Count(str, "\n") + 1
+}
+
+// Size returns the width and height of the string in cells. ANSI sequences are
+// ignored and characters wider than one cell (such as Chinese characters and
+// emojis) are appropriately measured.
+func Size(str string) (width, height int) {
+ width = Width(str)
+ height = Height(str)
+ return width, height
+}
diff --git a/vendor/charm.land/lipgloss/v2/style.go b/vendor/charm.land/lipgloss/v2/style.go
new file mode 100644
index 000000000..3cd659526
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/style.go
@@ -0,0 +1,637 @@
+package lipgloss
+
+import (
+ "image/color"
+ "strings"
+ "unicode"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+const (
+ // NBSP is the non-breaking space rune.
+ NBSP = '\u00A0'
+ tabWidthDefault = 4
+)
+
+// Property for a key.
+type propKey int64
+
+// Available properties.
+const (
+ // Boolean props come first.
+ boldKey propKey = 1 << iota
+ italicKey
+ strikethroughKey
+ reverseKey
+ blinkKey
+ faintKey
+ underlineSpacesKey
+ strikethroughSpacesKey
+ colorWhitespaceKey
+
+ // Non-boolean props.
+ underlineKey
+ foregroundKey
+ backgroundKey
+ underlineColorKey
+ widthKey
+ heightKey
+ alignHorizontalKey
+ alignVerticalKey
+
+ // Padding.
+ paddingTopKey
+ paddingRightKey
+ paddingBottomKey
+ paddingLeftKey
+ paddingCharKey
+
+ // Margins.
+ marginTopKey
+ marginRightKey
+ marginBottomKey
+ marginLeftKey
+ marginBackgroundKey
+ marginCharKey
+
+ // Border runes.
+ borderStyleKey
+
+ // Border edges.
+ borderTopKey
+ borderRightKey
+ borderBottomKey
+ borderLeftKey
+
+ // Border foreground colors.
+ borderTopForegroundKey
+ borderRightForegroundKey
+ borderBottomForegroundKey
+ borderLeftForegroundKey
+ borderForegroundBlendKey
+ borderForegroundBlendOffsetKey
+
+ // Border background colors.
+ borderTopBackgroundKey
+ borderRightBackgroundKey
+ borderBottomBackgroundKey
+ borderLeftBackgroundKey
+
+ inlineKey
+ maxWidthKey
+ maxHeightKey
+ tabWidthKey
+
+ transformKey
+
+ // Hyperlink.
+ linkKey
+ linkParamsKey
+)
+
+// props is a set of properties.
+type props int64
+
+// set sets a property.
+func (p props) set(k propKey) props {
+ return p | props(k)
+}
+
+// unset unsets a property.
+func (p props) unset(k propKey) props {
+ return p &^ props(k)
+}
+
+// has checks if a property is set.
+func (p props) has(k propKey) bool {
+ return p&props(k) != 0
+}
+
+// Underline is the style of the underline.
+//
+// Caveats:
+// - Not all terminals support all underline styles.
+// - Some terminals may render unsupported styles as standard underlines.
+// - Terminal themes may affect the visibility of different underline styles.
+type Underline = ansi.Underline
+
+const (
+ // UnderlineNone is no underline.
+ UnderlineNone = ansi.UnderlineNone
+ // UnderlineSingle is a single underline. This is the default when underline is enabled.
+ UnderlineSingle = ansi.UnderlineSingle
+ // UnderlineDouble is a double underline.
+ UnderlineDouble = ansi.UnderlineDouble
+ // UnderlineCurly is a curly underline.
+ UnderlineCurly = ansi.UnderlineCurly
+ // UnderlineDotted is a dotted underline.
+ UnderlineDotted = ansi.UnderlineDotted
+ // UnderlineDashed is a dashed underline.
+ UnderlineDashed = ansi.UnderlineDashed
+)
+
+// NewStyle returns a new, empty Style. While it's syntactic sugar for the
+// [Style]{} primitive, it's recommended to use this function for creating styles
+// in case the underlying implementation changes.
+func NewStyle() Style {
+ return Style{}
+}
+
+// Style contains a set of rules that comprise a style as a whole.
+type Style struct {
+ props props
+ value string
+
+ // hyperlink
+ link, linkParams string
+
+ // we store bool props values here
+ attrs int
+
+ // props that have values
+ fgColor color.Color
+ bgColor color.Color
+ ulColor color.Color
+
+ ul Underline
+
+ width int
+ height int
+
+ alignHorizontal Position
+ alignVertical Position
+
+ paddingTop int
+ paddingRight int
+ paddingBottom int
+ paddingLeft int
+ paddingChar rune
+
+ marginTop int
+ marginRight int
+ marginBottom int
+ marginLeft int
+ marginBgColor color.Color
+ marginChar rune
+
+ borderStyle Border
+ borderTopFgColor color.Color
+ borderRightFgColor color.Color
+ borderBottomFgColor color.Color
+ borderLeftFgColor color.Color
+ borderBlendFgColor []color.Color
+ borderForegroundBlendOffset int
+ borderTopBgColor color.Color
+ borderRightBgColor color.Color
+ borderBottomBgColor color.Color
+ borderLeftBgColor color.Color
+
+ maxWidth int
+ maxHeight int
+ tabWidth int
+
+ transform func(string) string
+}
+
+// joinString joins a list of strings into a single string separated with a
+// space.
+func joinString(strs ...string) string {
+ return strings.Join(strs, " ")
+}
+
+// SetString sets the underlying string value for this style. To render once
+// the underlying string is set, use the [Style.String]. This method is
+// a convenience for cases when having a stringer implementation is handy, such
+// as when using fmt.Sprintf. You can also simply define a style and render out
+// strings directly with [Style.Render].
+func (s Style) SetString(strs ...string) Style {
+ s.value = joinString(strs...)
+ return s
+}
+
+// Value returns the raw, unformatted, underlying string value for this style.
+func (s Style) Value() string {
+ return s.value
+}
+
+// String implements stringer for a Style, returning the rendered result based
+// on the rules in this style. An underlying string value must be set with
+// Style.SetString prior to using this method.
+func (s Style) String() string {
+ return s.Render()
+}
+
+// Copy returns a copy of this style, including any underlying string values.
+//
+// Deprecated: to copy just use assignment (i.e. a := b). All methods also
+// return a new style.
+func (s Style) Copy() Style {
+ return s
+}
+
+// Inherit overlays the style in the argument onto this style by copying each explicitly
+// set value from the argument style onto this style if it is not already explicitly set.
+// Existing set values are kept intact and not overwritten.
+//
+// Margins, padding, and underlying string values are not inherited.
+func (s Style) Inherit(i Style) Style {
+ for k := boldKey; k <= transformKey; k <<= 1 {
+ if !i.isSet(k) {
+ continue
+ }
+
+ switch k { //nolint:exhaustive
+ case marginTopKey, marginRightKey, marginBottomKey, marginLeftKey:
+ // Margins are not inherited
+ continue
+ case paddingTopKey, paddingRightKey, paddingBottomKey, paddingLeftKey:
+ // Padding is not inherited
+ continue
+ case backgroundKey:
+ // The margins also inherit the background color
+ if !s.isSet(marginBackgroundKey) && !i.isSet(marginBackgroundKey) {
+ s.set(marginBackgroundKey, i.bgColor)
+ }
+ }
+
+ if s.isSet(k) {
+ continue
+ }
+
+ s.setFrom(k, i)
+ }
+ return s
+}
+
+// Render applies the defined style formatting to a given string.
+func (s Style) Render(strs ...string) string {
+ if s.value != "" {
+ strs = append([]string{s.value}, strs...)
+ }
+
+ var (
+ str = joinString(strs...)
+
+ te ansi.Style
+ teSpace ansi.Style
+ teWhitespace ansi.Style
+
+ bold = s.getAsBool(boldKey, false)
+ italic = s.getAsBool(italicKey, false)
+ strikethrough = s.getAsBool(strikethroughKey, false)
+ reverse = s.getAsBool(reverseKey, false)
+ blink = s.getAsBool(blinkKey, false)
+ faint = s.getAsBool(faintKey, false)
+
+ fg = s.getAsColor(foregroundKey)
+ bg = s.getAsColor(backgroundKey)
+ ul = s.getAsColor(underlineColorKey)
+
+ underline = s.ul != UnderlineNone
+ width = s.getAsInt(widthKey)
+ height = s.getAsInt(heightKey)
+ horizontalAlign = s.getAsPosition(alignHorizontalKey)
+ verticalAlign = s.getAsPosition(alignVerticalKey)
+
+ topPadding = s.getAsInt(paddingTopKey)
+ rightPadding = s.getAsInt(paddingRightKey)
+ bottomPadding = s.getAsInt(paddingBottomKey)
+ leftPadding = s.getAsInt(paddingLeftKey)
+
+ horizontalBorderSize = s.GetHorizontalBorderSize()
+ verticalBorderSize = s.GetVerticalBorderSize()
+
+ colorWhitespace = s.getAsBool(colorWhitespaceKey, true)
+ inline = s.getAsBool(inlineKey, false)
+ maxWidth = s.getAsInt(maxWidthKey)
+ maxHeight = s.getAsInt(maxHeightKey)
+
+ underlineSpaces = s.getAsBool(underlineSpacesKey, false) || (underline && s.getAsBool(underlineSpacesKey, true))
+ strikethroughSpaces = s.getAsBool(strikethroughSpacesKey, false) || (strikethrough && s.getAsBool(strikethroughSpacesKey, true))
+
+ // Do we need to style whitespace (padding and space outside
+ // paragraphs) separately?
+ styleWhitespace = reverse
+
+ // Do we need to style spaces separately?
+ useSpaceStyler = (underline && !underlineSpaces) || (strikethrough && !strikethroughSpaces) || underlineSpaces || strikethroughSpaces
+
+ transform = s.getAsTransform(transformKey)
+
+ link, linkParams = s.GetHyperlink()
+ )
+
+ if transform != nil {
+ str = transform(str)
+ }
+
+ if s.props == 0 {
+ return s.maybeConvertTabs(str)
+ }
+
+ if bold {
+ te = te.Bold()
+ }
+ if italic {
+ te = te.Italic(true)
+ }
+ if underline {
+ te = te.Underline(true)
+ }
+ if reverse {
+ teWhitespace = teWhitespace.Reverse(true)
+ te = te.Reverse(true)
+ }
+ if blink {
+ te = te.Blink(true)
+ }
+ if faint {
+ te = te.Faint()
+ }
+
+ if fg != noColor {
+ te = te.ForegroundColor(fg)
+ if styleWhitespace {
+ teWhitespace = teWhitespace.ForegroundColor(fg)
+ }
+ if useSpaceStyler {
+ teSpace = teSpace.ForegroundColor(fg)
+ }
+ }
+
+ if bg != noColor {
+ te = te.BackgroundColor(bg)
+ if colorWhitespace {
+ teWhitespace = teWhitespace.BackgroundColor(bg)
+ }
+ if useSpaceStyler {
+ teSpace = teSpace.BackgroundColor(bg)
+ }
+ }
+
+ if ul != noColor {
+ te = te.UnderlineColor(ul)
+ if colorWhitespace {
+ teWhitespace = teWhitespace.UnderlineColor(ul)
+ }
+ if useSpaceStyler {
+ teSpace = teSpace.UnderlineColor(ul)
+ }
+ }
+
+ if underline {
+ te = te.UnderlineStyle(s.ul)
+ }
+ if strikethrough {
+ te = te.Strikethrough(true)
+ }
+
+ if underlineSpaces {
+ teSpace = teSpace.Underline(true)
+ }
+ if strikethroughSpaces {
+ teSpace = teSpace.Strikethrough(true)
+ }
+
+ // Potentially convert tabs to spaces
+ str = s.maybeConvertTabs(str)
+ // carriage returns can cause strange behaviour when rendering.
+ str = strings.ReplaceAll(str, "\r\n", "\n")
+
+ // Strip newlines in single line mode
+ if inline {
+ str = strings.ReplaceAll(str, "\n", "")
+ }
+
+ // Include borders in block size.
+ width -= horizontalBorderSize
+ height -= verticalBorderSize
+
+ // Word wrap
+ if !inline && width > 0 {
+ wrapAt := width - leftPadding - rightPadding
+ str = Wrap(str, wrapAt, "")
+ }
+
+ // Render core text
+ {
+ var b strings.Builder
+
+ isFirst := true
+ for line := range strings.SplitSeq(str, "\n") {
+ if isFirst {
+ isFirst = false
+ } else {
+ b.WriteRune('\n')
+ }
+ if useSpaceStyler {
+ // Look for spaces and apply a different styler
+ for _, r := range line {
+ if unicode.IsSpace(r) {
+ b.WriteString(teSpace.Styled(string(r)))
+ continue
+ }
+ b.WriteString(te.Styled(string(r)))
+ }
+ } else {
+ b.WriteString(te.Styled(line))
+ }
+ }
+
+ str = b.String()
+
+ if len(link) > 0 {
+ str = ansi.SetHyperlink(link, linkParams) + str + ansi.ResetHyperlink()
+ }
+ }
+
+ // Padding
+ if !inline { //nolint:nestif
+ padChar := s.paddingChar
+ if padChar == 0 {
+ padChar = ' '
+ }
+ if leftPadding > 0 {
+ var st *ansi.Style
+ if colorWhitespace || styleWhitespace {
+ st = &teWhitespace
+ }
+ str = padLeft(str, leftPadding, st, padChar)
+ }
+
+ if rightPadding > 0 {
+ var st *ansi.Style
+ if colorWhitespace || styleWhitespace {
+ st = &teWhitespace
+ }
+ str = padRight(str, rightPadding, st, padChar)
+ }
+
+ if topPadding > 0 {
+ str = strings.Repeat("\n", topPadding) + str
+ }
+
+ if bottomPadding > 0 {
+ str += strings.Repeat("\n", bottomPadding)
+ }
+ }
+
+ // Height
+ if height > 0 {
+ str = alignTextVertical(str, verticalAlign, height, nil)
+ }
+
+ // Set alignment. This will also pad short lines with spaces so that all
+ // lines are the same length, so we run it under a few different conditions
+ // beyond alignment.
+ {
+ numLines := strings.Count(str, "\n")
+
+ if numLines != 0 || width != 0 {
+ var st *ansi.Style
+ if colorWhitespace || styleWhitespace {
+ st = &teWhitespace
+ }
+ str = alignTextHorizontal(str, horizontalAlign, width, st)
+ }
+ }
+
+ if !inline {
+ str = s.applyBorder(str)
+ str = s.applyMargins(str, inline)
+ }
+
+ // Truncate according to MaxWidth
+ if maxWidth > 0 {
+ lines := strings.Split(str, "\n")
+
+ for i := range lines {
+ lines[i] = ansi.Truncate(lines[i], maxWidth, "")
+ }
+
+ str = strings.Join(lines, "\n")
+ }
+
+ // Truncate according to MaxHeight
+ if maxHeight > 0 {
+ lines := strings.Split(str, "\n")
+ height := min(maxHeight, len(lines))
+ if len(lines) > 0 {
+ str = strings.Join(lines[:height], "\n")
+ }
+ }
+
+ return str
+}
+
+func (s Style) maybeConvertTabs(str string) string {
+ tw := tabWidthDefault
+ if s.isSet(tabWidthKey) {
+ tw = s.getAsInt(tabWidthKey)
+ }
+ switch tw {
+ case -1:
+ return str
+ case 0:
+ return strings.ReplaceAll(str, "\t", "")
+ default:
+ return strings.ReplaceAll(str, "\t", strings.Repeat(" ", tw))
+ }
+}
+
+func (s Style) applyMargins(str string, inline bool) string {
+ var (
+ topMargin = s.getAsInt(marginTopKey)
+ rightMargin = s.getAsInt(marginRightKey)
+ bottomMargin = s.getAsInt(marginBottomKey)
+ leftMargin = s.getAsInt(marginLeftKey)
+
+ style ansi.Style
+ )
+
+ bgc := s.getAsColor(marginBackgroundKey)
+ if bgc != noColor {
+ style = style.BackgroundColor(bgc)
+ }
+
+ // Add left and right margin
+ marginChar := s.marginChar
+ if marginChar == 0 {
+ marginChar = ' '
+ }
+ str = padLeft(str, leftMargin, &style, marginChar)
+ str = padRight(str, rightMargin, &style, marginChar)
+
+ // Top/bottom margin
+ if !inline {
+ _, width := getLines(str)
+ spaces := strings.Repeat(" ", width)
+
+ if topMargin > 0 {
+ str = style.Styled(strings.Repeat(spaces+"\n", topMargin)) + str
+ }
+ if bottomMargin > 0 {
+ str += style.Styled(strings.Repeat("\n"+spaces, bottomMargin))
+ }
+ }
+
+ return str
+}
+
+// Apply left padding.
+func padLeft(str string, n int, style *ansi.Style, r rune) string {
+ return pad(str, -n, style, r)
+}
+
+// Apply right padding.
+func padRight(str string, n int, style *ansi.Style, r rune) string {
+ return pad(str, n, style, r)
+}
+
+// pad adds padding to either the left or right side of a string.
+// Positive values add to the right side while negative values
+// add to the left side.
+// r is the rune to use for padding. We use " " for margins and
+// "\u00A0" for padding so that the padding is preserved when the
+// string is copied and pasted.
+func pad(str string, n int, style *ansi.Style, r rune) string {
+ if n == 0 {
+ return str
+ }
+
+ sp := strings.Repeat(string(r), abs(n))
+ if style != nil {
+ sp = style.Styled(sp)
+ }
+
+ b := strings.Builder{}
+ isFirst := true
+ for line := range strings.SplitSeq(str, "\n") {
+ if isFirst {
+ isFirst = false
+ } else {
+ b.WriteRune('\n')
+ }
+ switch {
+ // pad right
+ case n > 0:
+ b.WriteString(line)
+ b.WriteString(sp)
+ // pad left
+ default:
+ b.WriteString(sp)
+ b.WriteString(line)
+ }
+ }
+
+ return b.String()
+}
+
+func abs(a int) int {
+ if a < 0 {
+ return -a
+ }
+
+ return a
+}
diff --git a/vendor/charm.land/lipgloss/v2/terminal.go b/vendor/charm.land/lipgloss/v2/terminal.go
new file mode 100644
index 000000000..a336abc77
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/terminal.go
@@ -0,0 +1,124 @@
+package lipgloss
+
+import (
+ "fmt"
+ "image/color"
+ "io"
+ "strings"
+ "time"
+
+ uv "github.com/charmbracelet/ultraviolet"
+ "github.com/charmbracelet/x/ansi"
+)
+
+// queryBackgroundColor queries the terminal for the background color.
+// If the terminal does not support querying the background color, nil is
+// returned.
+//
+// Note: you will need to set the input to raw mode before calling this
+// function.
+//
+// state, _ := term.MakeRaw(in.Fd())
+// defer term.Restore(in.Fd(), state)
+//
+// copied from x/term@v0.1.3.
+func queryBackgroundColor(in io.Reader, out io.Writer) (c color.Color, err error) {
+ err = queryTerminal(in, out, defaultQueryTimeout,
+ func(seq string, pa *ansi.Parser) bool {
+ switch {
+ case ansi.HasOscPrefix(seq):
+ switch pa.Command() {
+ case 11: // OSC 11
+ parts := strings.Split(string(pa.Data()), ";")
+ if len(parts) != 2 {
+ break // invalid, but we still need to parse the next sequence
+ }
+ c = ansi.XParseColor(parts[1])
+ }
+ case ansi.HasCsiPrefix(seq):
+ switch pa.Command() {
+ case ansi.Command('?', 0, 'c'): // DA1
+ return false
+ }
+ }
+ return true
+ }, ansi.RequestBackgroundColor+ansi.RequestPrimaryDeviceAttributes)
+ return
+}
+
+const defaultQueryTimeout = time.Second * 2
+
+// queryTerminalFilter is a function that filters input events using a type
+// switch. If false is returned, the QueryTerminal function will stop reading
+// input.
+type queryTerminalFilter func(seq string, pa *ansi.Parser) bool
+
+// queryTerminal queries the terminal for support of various features and
+// returns a list of response events.
+// Most of the time, you will need to set stdin to raw mode before calling this
+// function.
+// Note: This function will block until the terminal responds or the timeout
+// is reached.
+// copied from x/term@v0.1.3.
+func queryTerminal(
+ in io.Reader,
+ out io.Writer,
+ timeout time.Duration,
+ filter queryTerminalFilter,
+ query string,
+) error {
+ // We use [uv.NewCancelReader] because it uses a different Windows
+ // implementation than the on in the [cancelreader] library, which uses
+ // the Cancel IO API to cancel reads instead of using Overlapped IO.
+ rd, err := uv.NewCancelReader(in)
+ if err != nil {
+ return fmt.Errorf("could not create cancel reader: %w", err)
+ }
+
+ defer rd.Close() //nolint: errcheck
+
+ done := make(chan struct{}, 1)
+ defer close(done)
+ go func() {
+ select {
+ case <-done:
+ case <-time.After(timeout):
+ rd.Cancel()
+ }
+ }()
+
+ if _, err := io.WriteString(out, query); err != nil {
+ return fmt.Errorf("could not write query: %w", err)
+ }
+
+ pa := ansi.GetParser()
+ defer ansi.PutParser(pa)
+
+ var acc []byte // Accumulate partial responses before filtering
+ var buf [256]byte // 256 bytes should be enough for most responses
+ var state byte
+ for {
+ n, err := rd.Read(buf[:])
+ if err != nil {
+ return fmt.Errorf("could not read from input: %w", err)
+ }
+
+ p := buf[:]
+ for n > 0 {
+ seq, _, read, newState := ansi.DecodeSequence(p[:n], state, pa)
+ acc = append(acc, seq...)
+
+ if newState == ansi.NormalState {
+ if !filter(string(acc), pa) {
+ return nil
+ }
+
+ acc = acc[:0]
+ }
+
+ state = newState
+ n -= read
+ p = p[read:]
+ }
+ }
+}
diff --git a/vendor/charm.land/lipgloss/v2/unset.go b/vendor/charm.land/lipgloss/v2/unset.go
new file mode 100644
index 000000000..b81ee882a
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/unset.go
@@ -0,0 +1,359 @@
+package lipgloss
+
+// unset unsets a property from a style.
+func (s *Style) unset(key propKey) {
+ s.props = s.props.unset(key)
+}
+
+// UnsetBold removes the bold style rule, if set.
+func (s Style) UnsetBold() Style {
+ s.unset(boldKey)
+ return s
+}
+
+// UnsetItalic removes the italic style rule, if set.
+func (s Style) UnsetItalic() Style {
+ s.unset(italicKey)
+ return s
+}
+
+// UnsetUnderline removes the underline style rule, if set.
+func (s Style) UnsetUnderline() Style {
+ return s.Underline(false)
+}
+
+// UnsetStrikethrough removes the strikethrough style rule, if set.
+func (s Style) UnsetStrikethrough() Style {
+ s.unset(strikethroughKey)
+ return s
+}
+
+// UnsetReverse removes the reverse style rule, if set.
+func (s Style) UnsetReverse() Style {
+ s.unset(reverseKey)
+ return s
+}
+
+// UnsetBlink removes the blink style rule, if set.
+func (s Style) UnsetBlink() Style {
+ s.unset(blinkKey)
+ return s
+}
+
+// UnsetFaint removes the faint style rule, if set.
+func (s Style) UnsetFaint() Style {
+ s.unset(faintKey)
+ return s
+}
+
+// UnsetForeground removes the foreground style rule, if set.
+func (s Style) UnsetForeground() Style {
+ s.unset(foregroundKey)
+ return s
+}
+
+// UnsetBackground removes the background style rule, if set.
+func (s Style) UnsetBackground() Style {
+ s.unset(backgroundKey)
+ return s
+}
+
+// UnsetWidth removes the width style rule, if set.
+func (s Style) UnsetWidth() Style {
+ s.unset(widthKey)
+ return s
+}
+
+// UnsetHeight removes the height style rule, if set.
+func (s Style) UnsetHeight() Style {
+ s.unset(heightKey)
+ return s
+}
+
+// UnsetAlign removes the horizontal and vertical text alignment style rule, if set.
+func (s Style) UnsetAlign() Style {
+ s.unset(alignHorizontalKey)
+ s.unset(alignVerticalKey)
+ return s
+}
+
+// UnsetAlignHorizontal removes the horizontal text alignment style rule, if set.
+func (s Style) UnsetAlignHorizontal() Style {
+ s.unset(alignHorizontalKey)
+ return s
+}
+
+// UnsetAlignVertical removes the vertical text alignment style rule, if set.
+func (s Style) UnsetAlignVertical() Style {
+ s.unset(alignVerticalKey)
+ return s
+}
+
+// UnsetPadding removes all padding style rules.
+func (s Style) UnsetPadding() Style {
+ s.unset(paddingLeftKey)
+ s.unset(paddingRightKey)
+ s.unset(paddingTopKey)
+ s.unset(paddingBottomKey)
+ s.unset(paddingCharKey)
+ return s
+}
+
+// UnsetPaddingChar removes the padding character style rule, if set.
+func (s Style) UnsetPaddingChar() Style {
+ s.unset(paddingCharKey)
+ return s
+}
+
+// UnsetPaddingLeft removes the left padding style rule, if set.
+func (s Style) UnsetPaddingLeft() Style {
+ s.unset(paddingLeftKey)
+ return s
+}
+
+// UnsetPaddingRight removes the right padding style rule, if set.
+func (s Style) UnsetPaddingRight() Style {
+ s.unset(paddingRightKey)
+ return s
+}
+
+// UnsetPaddingTop removes the top padding style rule, if set.
+func (s Style) UnsetPaddingTop() Style {
+ s.unset(paddingTopKey)
+ return s
+}
+
+// UnsetPaddingBottom removes the bottom padding style rule, if set.
+func (s Style) UnsetPaddingBottom() Style {
+ s.unset(paddingBottomKey)
+ return s
+}
+
+// UnsetColorWhitespace removes the rule for coloring padding, if set.
+func (s Style) UnsetColorWhitespace() Style {
+ s.unset(colorWhitespaceKey)
+ return s
+}
+
+// UnsetMargins removes all margin style rules.
+func (s Style) UnsetMargins() Style {
+ s.unset(marginLeftKey)
+ s.unset(marginRightKey)
+ s.unset(marginTopKey)
+ s.unset(marginBottomKey)
+ return s
+}
+
+// UnsetMarginLeft removes the left margin style rule, if set.
+func (s Style) UnsetMarginLeft() Style {
+ s.unset(marginLeftKey)
+ return s
+}
+
+// UnsetMarginRight removes the right margin style rule, if set.
+func (s Style) UnsetMarginRight() Style {
+ s.unset(marginRightKey)
+ return s
+}
+
+// UnsetMarginTop removes the top margin style rule, if set.
+func (s Style) UnsetMarginTop() Style {
+ s.unset(marginTopKey)
+ return s
+}
+
+// UnsetMarginBottom removes the bottom margin style rule, if set.
+func (s Style) UnsetMarginBottom() Style {
+ s.unset(marginBottomKey)
+ return s
+}
+
+// UnsetMarginBackground removes the margin's background color. Note that the
+// margin's background color can be set from the background color of another
+// style during inheritance.
+func (s Style) UnsetMarginBackground() Style {
+ s.unset(marginBackgroundKey)
+ return s
+}
+
+// UnsetBorderStyle removes the border style rule, if set.
+func (s Style) UnsetBorderStyle() Style {
+ s.unset(borderStyleKey)
+ return s
+}
+
+// UnsetBorderTop removes the border top style rule, if set.
+func (s Style) UnsetBorderTop() Style {
+ s.unset(borderTopKey)
+ return s
+}
+
+// UnsetBorderRight removes the border right style rule, if set.
+func (s Style) UnsetBorderRight() Style {
+ s.unset(borderRightKey)
+ return s
+}
+
+// UnsetBorderBottom removes the border bottom style rule, if set.
+func (s Style) UnsetBorderBottom() Style {
+ s.unset(borderBottomKey)
+ return s
+}
+
+// UnsetBorderLeft removes the border left style rule, if set.
+func (s Style) UnsetBorderLeft() Style {
+ s.unset(borderLeftKey)
+ return s
+}
+
+// UnsetBorderForeground removes all border foreground color styles, if set.
+func (s Style) UnsetBorderForeground() Style {
+ s.unset(borderTopForegroundKey)
+ s.unset(borderRightForegroundKey)
+ s.unset(borderBottomForegroundKey)
+ s.unset(borderLeftForegroundKey)
+ return s
+}
+
+// UnsetBorderTopForeground removes the top border foreground color rule,
+// if set.
+func (s Style) UnsetBorderTopForeground() Style {
+ s.unset(borderTopForegroundKey)
+ return s
+}
+
+// UnsetBorderRightForeground removes the right border foreground color rule,
+// if set.
+func (s Style) UnsetBorderRightForeground() Style {
+ s.unset(borderRightForegroundKey)
+ return s
+}
+
+// UnsetBorderBottomForeground removes the bottom border foreground color
+// rule, if set.
+func (s Style) UnsetBorderBottomForeground() Style {
+ s.unset(borderBottomForegroundKey)
+ return s
+}
+
+// UnsetBorderLeftForeground removes the left border foreground color rule,
+// if set.
+func (s Style) UnsetBorderLeftForeground() Style {
+ s.unset(borderLeftForegroundKey)
+ return s
+}
+
+// UnsetBorderForegroundBlend removes the border blend foreground color rules,
+// if set.
+func (s Style) UnsetBorderForegroundBlend() Style {
+ s.unset(borderForegroundBlendKey)
+ return s
+}
+
+// UnsetBorderForegroundBlendOffset removes the border blend offset style rule,
+// if set.
+func (s Style) UnsetBorderForegroundBlendOffset() Style {
+ s.unset(borderForegroundBlendOffsetKey)
+ return s
+}
+
+// UnsetBorderBackground removes all border background color styles, if
+// set.
+func (s Style) UnsetBorderBackground() Style {
+ s.unset(borderTopBackgroundKey)
+ s.unset(borderRightBackgroundKey)
+ s.unset(borderBottomBackgroundKey)
+ s.unset(borderLeftBackgroundKey)
+ return s
+}
+
+// UnsetBorderTopBackgroundColor removes the top border background color rule,
+// if set.
+//
+// Deprecated: This function simply calls Style.UnsetBorderTopBackground.
+func (s Style) UnsetBorderTopBackgroundColor() Style {
+ return s.UnsetBorderTopBackground()
+}
+
+// UnsetBorderTopBackground removes the top border background color rule,
+// if set.
+func (s Style) UnsetBorderTopBackground() Style {
+ s.unset(borderTopBackgroundKey)
+ return s
+}
+
+// UnsetBorderRightBackground removes the right border background color
+// rule, if set.
+func (s Style) UnsetBorderRightBackground() Style {
+ s.unset(borderRightBackgroundKey)
+ return s
+}
+
+// UnsetBorderBottomBackground removes the bottom border background color
+// rule, if set.
+func (s Style) UnsetBorderBottomBackground() Style {
+ s.unset(borderBottomBackgroundKey)
+ return s
+}
+
+// UnsetBorderLeftBackground removes the left border color rule, if set.
+func (s Style) UnsetBorderLeftBackground() Style {
+ s.unset(borderLeftBackgroundKey)
+ return s
+}
+
+// UnsetInline removes the inline style rule, if set.
+func (s Style) UnsetInline() Style {
+ s.unset(inlineKey)
+ return s
+}
+
+// UnsetMaxWidth removes the max width style rule, if set.
+func (s Style) UnsetMaxWidth() Style {
+ s.unset(maxWidthKey)
+ return s
+}
+
+// UnsetMaxHeight removes the max height style rule, if set.
+func (s Style) UnsetMaxHeight() Style {
+ s.unset(maxHeightKey)
+ return s
+}
+
+// UnsetTabWidth removes the tab width style rule, if set.
+func (s Style) UnsetTabWidth() Style {
+ s.unset(tabWidthKey)
+ return s
+}
+
+// UnsetUnderlineSpaces removes the value set by UnderlineSpaces.
+func (s Style) UnsetUnderlineSpaces() Style {
+ s.unset(underlineSpacesKey)
+ return s
+}
+
+// UnsetStrikethroughSpaces removes the value set by StrikethroughSpaces.
+func (s Style) UnsetStrikethroughSpaces() Style {
+ s.unset(strikethroughSpacesKey)
+ return s
+}
+
+// UnsetTransform removes the value set by Transform.
+func (s Style) UnsetTransform() Style {
+ s.unset(transformKey)
+ return s
+}
+
+// UnsetHyperlink removes the value set by Hyperlink.
+func (s Style) UnsetHyperlink() Style {
+ s.unset(linkKey)
+ s.unset(linkParamsKey)
+ s.link, s.linkParams = "", "" // save memory
+ return s
+}
+
+// UnsetString sets the underlying string value to the empty string.
+func (s Style) UnsetString() Style {
+ s.value = ""
+ return s
+}
diff --git a/vendor/charm.land/lipgloss/v2/whitespace.go b/vendor/charm.land/lipgloss/v2/whitespace.go
new file mode 100644
index 000000000..e353a076b
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/whitespace.go
@@ -0,0 +1,76 @@
+package lipgloss
+
+import (
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// whitespace is a whitespace renderer.
+type whitespace struct {
+ chars string
+ style Style
+}
+
+// newWhitespace creates a new whitespace renderer.
+func newWhitespace(opts ...WhitespaceOption) *whitespace {
+ w := &whitespace{}
+ for _, opt := range opts {
+ opt(w)
+ }
+ return w
+}
+
+// Render whitespaces.
+func (w whitespace) render(width int) string {
+ if w.chars == "" {
+ w.chars = " "
+ }
+
+ r := []rune(w.chars)
+ j := 0
+ b := strings.Builder{}
+
+ // Cycle through runes and print them into the whitespace.
+ for i := 0; i < width; {
+ b.WriteRune(r[j])
+ // Measure the width of the rune we just wrote, ensuring we always
+ // make progress to avoid infinite loops with zero-width characters
+ // like tabs.
+ runeWidth := ansi.StringWidth(string(r[j]))
+ if runeWidth < 1 {
+ runeWidth = 1
+ }
+ i += runeWidth
+ j++
+ if j >= len(r) {
+ j = 0
+ }
+ }
+
+ // Fill any extra gaps white spaces. This might be necessary if any runes
+ // are more than one cell wide, which could leave a one-rune gap.
+ short := width - ansi.StringWidth(b.String())
+ if short > 0 {
+ b.WriteString(strings.Repeat(" ", short))
+ }
+
+ return w.style.Render(b.String())
+}
+
+// WhitespaceOption sets a styling rule for rendering whitespace.
+type WhitespaceOption func(*whitespace)
+
+// WithWhitespaceStyle sets the style for the whitespace.
+func WithWhitespaceStyle(s Style) WhitespaceOption {
+ return func(w *whitespace) {
+ w.style = s
+ }
+}
+
+// WithWhitespaceChars sets the characters to be rendered in the whitespace.
+func WithWhitespaceChars(s string) WhitespaceOption {
+ return func(w *whitespace) {
+ w.chars = s
+ }
+}
diff --git a/vendor/charm.land/lipgloss/v2/wrap.go b/vendor/charm.land/lipgloss/v2/wrap.go
new file mode 100644
index 000000000..ca0a1e239
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/wrap.go
@@ -0,0 +1,107 @@
+package lipgloss
+
+import (
+ "bytes"
+ "io"
+
+ uv "github.com/charmbracelet/ultraviolet"
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Wrap wraps the given string to the given width, preserving ANSI styles and links.
+func Wrap(s string, width int, breakpoints string) string {
+ var buf bytes.Buffer
+ s = ansi.Wrap(s, width, breakpoints)
+ w := NewWrapWriter(&buf)
+ defer w.Close() //nolint:errcheck
+ _, _ = io.WriteString(w, s)
+ return buf.String()
+}
+
+// WrapWriter is a writer that writes to a buffer and keeps track of the
+// current pen style and link state for the purpose of wrapping with newlines.
+//
+// When it encounters a newline, it resets the style and link, writes the
+// newline, and then reapplies the style and link to the next line.
+type WrapWriter struct {
+ w io.Writer
+ p *ansi.Parser
+ style uv.Style
+ link uv.Link
+}
+
+// NewWrapWriter returns a new [WrapWriter].
+func NewWrapWriter(w io.Writer) *WrapWriter {
+ pw := &WrapWriter{w: w}
+ pw.p = ansi.GetParser()
+ handleCsi := func(cmd ansi.Cmd, params ansi.Params) {
+ if cmd == 'm' {
+ uv.ReadStyle(params, &pw.style)
+ }
+ }
+ handleOsc := func(cmd int, data []byte) {
+ if cmd == 8 {
+ uv.ReadLink(data, &pw.link)
+ }
+ }
+ pw.p.SetHandler(ansi.Handler{
+ HandleCsi: handleCsi,
+ HandleOsc: handleOsc,
+ })
+ return pw
+}
+
+// Style returns the current pen style.
+func (w *WrapWriter) Style() uv.Style {
+ return w.style
+}
+
+// Link returns the current pen link.
+func (w *WrapWriter) Link() uv.Link {
+ return w.link
+}
+
+// Write writes to the buffer.
+func (w *WrapWriter) Write(p []byte) (int, error) {
+ for i := range p {
+ b := p[i]
+ w.p.Advance(b)
+ if b == '\n' {
+ if !w.style.IsZero() {
+ _, _ = w.w.Write([]byte(ansi.ResetStyle))
+ }
+ if !w.link.IsZero() {
+ _, _ = w.w.Write([]byte(ansi.ResetHyperlink()))
+ }
+ }
+
+ _, _ = w.w.Write([]byte{b})
+ if b == '\n' {
+ if !w.link.IsZero() {
+ _, _ = w.w.Write([]byte(ansi.SetHyperlink(w.link.URL, w.link.Params)))
+ }
+ if !w.style.IsZero() {
+ _, _ = w.w.Write([]byte(w.style.String()))
+ }
+ }
+ }
+
+ return len(p), nil
+}
+
+// Close closes the writer, resets the style and link if necessary, and releases
+// its parser. Calling it is performance critical, but forgetting it does not
+// cause safety issues or leaks.
+func (w *WrapWriter) Close() error {
+ if !w.style.IsZero() {
+ _, _ = w.w.Write([]byte(ansi.ResetStyle))
+ }
+ if !w.link.IsZero() {
+ _, _ = w.w.Write([]byte(ansi.ResetHyperlink()))
+ }
+ if w.p != nil {
+ ansi.PutParser(w.p)
+ w.p = nil
+ }
+ return nil
+}
diff --git a/vendor/charm.land/lipgloss/v2/writer.go b/vendor/charm.land/lipgloss/v2/writer.go
new file mode 100644
index 000000000..78b48b8d3
--- /dev/null
+++ b/vendor/charm.land/lipgloss/v2/writer.go
@@ -0,0 +1,160 @@
+package lipgloss
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+
+ "github.com/charmbracelet/colorprofile"
+)
+
+// Writer is the default writer that prints to stdout, automatically
+// downsampling colors when necessary.
+var Writer = colorprofile.NewWriter(os.Stdout, os.Environ())
+
+// Println to stdout, automatically downsampling colors when necessary, ending
+// with a trailing newline.
+//
+// Example:
+//
+// str := NewStyle().
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("breakfast")
+//
+// Println("Time for a", str, "sandwich!")
+func Println(v ...any) (int, error) {
+ return fmt.Fprintln(Writer, v...) //nolint:wrapcheck
+}
+
+// Printf prints formatted text to stdout, automatically downsampling colors
+// when necessary.
+//
+// Example:
+//
+// str := NewStyle().
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("knuckle")
+//
+// Printf("Time for a %s sandwich!\n", str)
+func Printf(format string, v ...any) (int, error) {
+ return fmt.Fprintf(Writer, format, v...) //nolint:wrapcheck
+}
+
+// Print to stdout, automatically downsampling colors when necessary.
+//
+// Example:
+//
+// str := NewStyle().
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("Who wants marmalade?\n")
+//
+// Print(str)
+func Print(v ...any) (int, error) {
+ return fmt.Fprint(Writer, v...) //nolint:wrapcheck
+}
+
+// Fprint pritnts to the given writer, automatically downsampling colors when
+// necessary.
+//
+// Example:
+//
+// str := NewStyle().
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("guzzle")
+//
+// Fprint(os.Stderr, "I %s horchata pretty much all the time.\n", str)
+func Fprint(w io.Writer, v ...any) (int, error) {
+ return fmt.Fprint(colorprofile.NewWriter(w, os.Environ()), v...) //nolint:wrapcheck
+}
+
+// Fprintln prints to the given writer, automatically downsampling colors when
+// necessary, and ending with a trailing newline.
+//
+// Example:
+//
+// str := NewStyle().
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("Sandwich time!")
+//
+// Fprintln(os.Stderr, str)
+func Fprintln(w io.Writer, v ...any) (int, error) {
+ return fmt.Fprintln(colorprofile.NewWriter(w, os.Environ()), v...) //nolint:wrapcheck
+}
+
+// Fprintf prints text to a writer, against the given format, automatically
+// downsampling colors when necessary.
+//
+// Example:
+//
+// str := NewStyle().
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("artichokes")
+//
+// Fprintf(os.Stderr, "I really love %s!\n", food)
+func Fprintf(w io.Writer, format string, v ...any) (int, error) {
+ return fmt.Fprintf(colorprofile.NewWriter(w, os.Environ()), format, v...) //nolint:wrapcheck
+}
+
+// Sprint returns a string for stdout, automatically downsampling colors when
+// necessary.
+//
+// Example:
+//
+// str := NewStyle().
+// Faint(true).
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("I love to eat")
+//
+// str = Sprint(str)
+func Sprint(v ...any) string {
+ var buf bytes.Buffer
+ w := colorprofile.Writer{
+ Forward: &buf,
+ Profile: Writer.Profile,
+ }
+ fmt.Fprint(&w, v...) //nolint:errcheck
+ return buf.String()
+}
+
+// Sprintln returns a string for stdout, automatically downsampling colors when
+// necessary, and ending with a trailing newline.
+//
+// Example:
+//
+// str := NewStyle().
+// Bold(true).
+// Foreground(lipgloss.Color("#6a00ff")).
+// Render("Yummy!")
+//
+// str = Sprintln(str)
+func Sprintln(v ...any) string {
+ var buf bytes.Buffer
+ w := colorprofile.Writer{
+ Forward: &buf,
+ Profile: Writer.Profile,
+ }
+ fmt.Fprintln(&w, v...) //nolint:errcheck
+ return buf.String()
+}
+
+// Sprintf returns a formatted string for stdout, automatically downsampling
+// colors when necessary.
+//
+// Example:
+//
+// str := NewStyle().
+// Bold(true).
+// Foreground(lipgloss.Color("#fccaee")).
+// Render("Cantaloupe")
+//
+// str = Sprintf("I really love %s!", str)
+func Sprintf(format string, v ...any) string {
+ var buf bytes.Buffer
+ w := colorprofile.Writer{
+ Forward: &buf,
+ Profile: Writer.Profile,
+ }
+ fmt.Fprintf(&w, format, v...) //nolint:errcheck
+ return buf.String()
+}
diff --git a/vendor/github.com/IBM/vpc-go-sdk/common/version.go b/vendor/github.com/IBM/vpc-go-sdk/common/version.go
index 4ef3c64d1..4ffa237d6 100644
--- a/vendor/github.com/IBM/vpc-go-sdk/common/version.go
+++ b/vendor/github.com/IBM/vpc-go-sdk/common/version.go
@@ -1,4 +1,4 @@
package common
// Version of the SDK
-const Version = "0.87.1"
+const Version = "0.88.0"
diff --git a/vendor/github.com/IBM/vpc-go-sdk/vpcv1/vpc_v1.go b/vendor/github.com/IBM/vpc-go-sdk/vpcv1/vpc_v1.go
index f27f2a144..0a9c33e3a 100644
--- a/vendor/github.com/IBM/vpc-go-sdk/vpcv1/vpc_v1.go
+++ b/vendor/github.com/IBM/vpc-go-sdk/vpcv1/vpc_v1.go
@@ -15,7 +15,7 @@
*/
/*
- * IBM OpenAPI SDK Code Generator Version: 3.114.4-9b56d441-20260612-210048
+ * IBM OpenAPI SDK Code Generator Version: 3.116.0-df613dbc-20260803-154903
*/
// Package vpcv1 : Operations and models for the VpcV1 service
@@ -47,7 +47,7 @@ type VpcV1 struct {
Generation *int64
// The API version, in format `YYYY-MM-DD`. For the API behavior documented here, specify any date between `2026-04-07`
- // and `2026-07-08`.
+ // and `2026-08-04`.
Version *string
}
@@ -68,7 +68,7 @@ type VpcV1Options struct {
Generation *int64
// The API version, in format `YYYY-MM-DD`. For the API behavior documented here, specify any date between `2026-04-07`
- // and `2026-07-08`.
+ // and `2026-08-04`.
Version *string
}
@@ -133,7 +133,7 @@ func NewVpcV1(options *VpcV1Options) (service *VpcV1, err error) {
}
if options.Version == nil {
- options.Version = core.StringPtr("2026-06-23")
+ options.Version = core.StringPtr("2026-07-21")
}
service = &VpcV1{
@@ -12985,6 +12985,82 @@ func (vpc *VpcV1) GetInstanceInitializationWithContext(ctx context.Context, getI
return
}
+// CreateInstanceReinitialization : Reinitialize an instance
+// This request reinitializes an instance with the information in a provided instance reinitialize prototype object. The
+// instance must be stopped. Upon successful reinitiatilization, the instance will be started automatically. Capacity
+// may not be available for the instance to become `running`.
+//
+// Instances provisioned from a `catalog_offering` cannot be reinitialized.
+//
+// This operation cannot be reversed. The previous initialization data will be fully replaced, the current boot volume
+// will be destroyed and replaced, any local disks will be wiped, and the boot volume attachment identifier will change.
+func (vpc *VpcV1) CreateInstanceReinitialization(createInstanceReinitializationOptions *CreateInstanceReinitializationOptions) (response *core.DetailedResponse, err error) {
+ response, err = vpc.CreateInstanceReinitializationWithContext(context.Background(), createInstanceReinitializationOptions)
+ err = core.RepurposeSDKProblem(err, "")
+ return
+}
+
+// CreateInstanceReinitializationWithContext is an alternate form of the CreateInstanceReinitialization method which supports a Context parameter
+func (vpc *VpcV1) CreateInstanceReinitializationWithContext(ctx context.Context, createInstanceReinitializationOptions *CreateInstanceReinitializationOptions) (response *core.DetailedResponse, err error) {
+ err = core.ValidateNotNil(createInstanceReinitializationOptions, "createInstanceReinitializationOptions cannot be nil")
+ if err != nil {
+ err = core.SDKErrorf(err, "", "unexpected-nil-param", common.GetComponentInfo())
+ return
+ }
+ err = core.ValidateStruct(createInstanceReinitializationOptions, "createInstanceReinitializationOptions")
+ if err != nil {
+ err = core.SDKErrorf(err, "", "struct-validation-error", common.GetComponentInfo())
+ return
+ }
+
+ pathParamsMap := map[string]string{
+ "id": *createInstanceReinitializationOptions.ID,
+ }
+
+ builder := core.NewRequestBuilder(core.POST)
+ builder = builder.WithContext(ctx)
+ builder.EnableGzipCompression = vpc.GetEnableGzipCompression()
+ _, err = builder.ResolveRequestURL(vpc.Service.Options.URL, `/instances/{id}/reinitialize`, pathParamsMap)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "url-resolve-error", common.GetComponentInfo())
+ return
+ }
+
+ sdkHeaders := common.GetSdkHeaders("vpc", "V1", "CreateInstanceReinitialization")
+ for headerName, headerValue := range sdkHeaders {
+ builder.AddHeader(headerName, headerValue)
+ }
+
+ for headerName, headerValue := range createInstanceReinitializationOptions.Headers {
+ builder.AddHeader(headerName, headerValue)
+ }
+ builder.AddHeader("Content-Type", "application/json")
+
+ builder.AddQuery("version", fmt.Sprint(*vpc.Version))
+ builder.AddQuery("generation", fmt.Sprint(*vpc.Generation))
+
+ _, err = builder.SetBodyContentJSON(createInstanceReinitializationOptions.InstanceReinitializePrototype)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "set-json-body-error", common.GetComponentInfo())
+ return
+ }
+
+ request, err := builder.Build()
+ if err != nil {
+ err = core.SDKErrorf(err, "", "build-error", common.GetComponentInfo())
+ return
+ }
+
+ response, err = vpc.Service.Request(request, nil)
+ if err != nil {
+ core.EnrichHTTPProblem(err, "create_instance_reinitialization", getServiceComponentInfo())
+ err = core.SDKErrorf(err, "", "http-request-err", common.GetComponentInfo())
+ return
+ }
+
+ return
+}
+
// CreateInstanceAction : Create an instance action
// This request creates a new action which will be queued up to run as soon as any pending or running actions have
// completed.
@@ -36413,7 +36489,7 @@ func (vpc *VpcV1) UpdateVPNServerRouteWithContext(ctx context.Context, updateVPN
return
}
func getServiceComponentInfo() *core.ProblemComponent {
- return core.NewProblemComponent(DefaultServiceName, "2026-06-23")
+ return core.NewProblemComponent(DefaultServiceName, "2026-07-21")
}
// AccountIdentity : Identifies an account by a unique property.
@@ -47881,6 +47957,44 @@ func (options *CreateInstanceOptions) SetHeaders(param map[string]string) *Creat
return options
}
+// CreateInstanceReinitializationOptions : The CreateInstanceReinitialization options.
+type CreateInstanceReinitializationOptions struct {
+ // The instance identifier.
+ ID *string `json:"id" validate:"required,ne="`
+
+ // The instance reinitialize prototype object.
+ InstanceReinitializePrototype InstanceReinitializePrototypeIntf `json:"InstanceReinitializePrototype" validate:"required"`
+
+ // Allows users to set headers on API requests.
+ Headers map[string]string
+}
+
+// NewCreateInstanceReinitializationOptions : Instantiate CreateInstanceReinitializationOptions
+func (*VpcV1) NewCreateInstanceReinitializationOptions(id string, instanceReinitializePrototype InstanceReinitializePrototypeIntf) *CreateInstanceReinitializationOptions {
+ return &CreateInstanceReinitializationOptions{
+ ID: core.StringPtr(id),
+ InstanceReinitializePrototype: instanceReinitializePrototype,
+ }
+}
+
+// SetID : Allow user to set ID
+func (_options *CreateInstanceReinitializationOptions) SetID(id string) *CreateInstanceReinitializationOptions {
+ _options.ID = core.StringPtr(id)
+ return _options
+}
+
+// SetInstanceReinitializePrototype : Allow user to set InstanceReinitializePrototype
+func (_options *CreateInstanceReinitializationOptions) SetInstanceReinitializePrototype(instanceReinitializePrototype InstanceReinitializePrototypeIntf) *CreateInstanceReinitializationOptions {
+ _options.InstanceReinitializePrototype = instanceReinitializePrototype
+ return _options
+}
+
+// SetHeaders : Allow user to set Headers
+func (options *CreateInstanceReinitializationOptions) SetHeaders(param map[string]string) *CreateInstanceReinitializationOptions {
+ options.Headers = param
+ return options
+}
+
// CreateInstanceTemplateOptions : The CreateInstanceTemplate options.
type CreateInstanceTemplateOptions struct {
// The instance template prototype object.
@@ -73366,8 +73480,9 @@ type InstancePrototype struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not
- // subsequently managed. Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and
+ // can only be changed by reinitializing the instance. Accordingly, it is reflected as
+ // an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization)
// property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -73386,8 +73501,8 @@ type InstancePrototype struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -73719,6 +73834,87 @@ func UnmarshalInstanceReference(m map[string]json.RawMessage, result interface{}
return
}
+// InstanceReinitializePrototype : InstanceReinitializePrototype struct
+// Models which "extend" this model:
+// - InstanceReinitializePrototypeInstanceReinitializeByImage
+// - InstanceReinitializePrototypeInstanceReinitializeByVolume
+// - InstanceReinitializePrototypeInstanceReinitializeBySnapshot
+type InstanceReinitializePrototype struct {
+ // The default trusted profile configuration to use for this virtual server instance.
+ // If not specified, the instance will be reinitialized without a default trusted
+ // profile.
+ //
+ // This property's value is used when reinitializing the virtual server instance, and
+ // can only be changed by reinitializing the instance. Accordingly, it is reflected as
+ // an [instance
+ // initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization)
+ // property.
+ DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
+
+ // The public SSH keys for the reinitialized instance. The keys will be made available to the virtual server instance
+ // as cloud-init vendor data. For cloud-init enabled images, the keys will also be added as SSH authorized keys for the
+ // [default user]
+ // (https://cloud.ibm.com/docs/vpc?topic=vpc-vsi_is_connecting_linux#determining-default-user-account).
+ //
+ // For Windows images, only keys with a `type` value of `rsa` must be specified, and one will be selected to encrypt
+ // [the administrator password](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization). Keys are optional for
+ // other images.
+ //
+ // If no keys are specified, the instance will be reinitialized without a key.
+ Keys []KeyIdentityIntf `json:"keys,omitempty"`
+
+ // The [user data](https://cloud.ibm.com/docs/vpc?topic=vpc-user-data) to make available when setting up the virtual
+ // server instance. If not specified, the instance will be reinitialized without user data.
+ UserData *string `json:"user_data,omitempty"`
+
+ // The boot volume attachment for the virtual server instance. If not specified,
+ // a new boot volume attachment will be created.
+ BootVolumeAttachment *VolumeAttachmentPrototypeInstanceByImageContext `json:"boot_volume_attachment,omitempty"`
+
+ // The image to use when reinitializing the virtual server instance.
+ Image ImageIdentityIntf `json:"image,omitempty"`
+}
+
+func (*InstanceReinitializePrototype) isaInstanceReinitializePrototype() bool {
+ return true
+}
+
+type InstanceReinitializePrototypeIntf interface {
+ isaInstanceReinitializePrototype() bool
+}
+
+// UnmarshalInstanceReinitializePrototype unmarshals an instance of InstanceReinitializePrototype from the specified map of raw messages.
+func UnmarshalInstanceReinitializePrototype(m map[string]json.RawMessage, result interface{}) (err error) {
+ obj := new(InstanceReinitializePrototype)
+ err = core.UnmarshalModel(m, "default_trusted_profile", &obj.DefaultTrustedProfile, UnmarshalInstanceDefaultTrustedProfilePrototype)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "default_trusted_profile-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "keys", &obj.Keys, UnmarshalKeyIdentity)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "keys-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalPrimitive(m, "user_data", &obj.UserData)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "user_data-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "boot_volume_attachment", &obj.BootVolumeAttachment, UnmarshalVolumeAttachmentPrototypeInstanceByImageContext)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "boot_volume_attachment-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "image", &obj.Image, UnmarshalImageIdentity)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "image-error", common.GetComponentInfo())
+ return
+ }
+ reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+ return
+}
+
// InstanceReservationAffinity : InstanceReservationAffinity struct
type InstanceReservationAffinity struct {
// The reservation affinity policy to use for this virtual server instance:
@@ -74377,8 +74573,9 @@ type InstanceTemplate struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not
- // subsequently managed. Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and
+ // can only be changed by reinitializing the instance. Accordingly, it is reflected as
+ // an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization)
// property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -74403,8 +74600,8 @@ type InstanceTemplate struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -74884,8 +75081,9 @@ type InstanceTemplatePrototype struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not
- // subsequently managed. Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and
+ // can only be changed by reinitializing the instance. Accordingly, it is reflected as
+ // an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization)
// property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -74904,8 +75102,8 @@ type InstanceTemplatePrototype struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -136440,8 +136638,8 @@ type InstancePrototypeInstanceByCatalogOffering struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -136459,8 +136657,8 @@ type InstancePrototypeInstanceByCatalogOffering struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -136743,8 +136941,8 @@ type InstancePrototypeInstanceByImage struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -136762,8 +136960,8 @@ type InstancePrototypeInstanceByImage struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -137038,8 +137236,8 @@ type InstancePrototypeInstanceBySourceSnapshot struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -137057,8 +137255,8 @@ type InstancePrototypeInstanceBySourceSnapshot struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -137328,8 +137526,8 @@ type InstancePrototypeInstanceBySourceTemplate struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -137347,8 +137545,8 @@ type InstancePrototypeInstanceBySourceTemplate struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -137650,8 +137848,8 @@ type InstancePrototypeInstanceByVolume struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -137669,8 +137867,8 @@ type InstancePrototypeInstanceByVolume struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -137915,6 +138113,238 @@ func UnmarshalInstancePrototypeInstanceByVolume(m map[string]json.RawMessage, re
return
}
+// InstanceReinitializePrototypeInstanceReinitializeByImage : Reinitialize an instance by using an image. The image must be within the same operating system family as the current
+// instance image, and must have the same licensing model.
+// This model "extends" InstanceReinitializePrototype
+type InstanceReinitializePrototypeInstanceReinitializeByImage struct {
+ // The default trusted profile configuration to use for this virtual server instance. If not specified, the instance
+ // will be reinitialized without a default trusted profile.
+ //
+ // This property's value is used when reinitializing the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
+ // initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
+ DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
+
+ // The public SSH keys for the reinitialized instance. The keys will be made available to the virtual server instance
+ // as cloud-init vendor data. For cloud-init enabled images, the keys will also be added as SSH authorized keys for the
+ // [default user]
+ // (https://cloud.ibm.com/docs/vpc?topic=vpc-vsi_is_connecting_linux#determining-default-user-account).
+ //
+ // For Windows images, only keys with a `type` value of `rsa` must be specified, and one will be selected to encrypt
+ // [the administrator password](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization). Keys are optional for
+ // other images.
+ //
+ // If no keys are specified, the instance will be reinitialized without a key.
+ Keys []KeyIdentityIntf `json:"keys,omitempty"`
+
+ // The [user data](https://cloud.ibm.com/docs/vpc?topic=vpc-user-data) to make available when setting up the virtual
+ // server instance. If not specified, the instance will be reinitialized without user data.
+ UserData *string `json:"user_data,omitempty"`
+
+ // The boot volume attachment for the virtual server instance. If not specified,
+ // a new boot volume attachment will be created.
+ BootVolumeAttachment *VolumeAttachmentPrototypeInstanceByImageContext `json:"boot_volume_attachment,omitempty"`
+
+ // The image to use when reinitializing the virtual server instance.
+ Image ImageIdentityIntf `json:"image" validate:"required"`
+}
+
+// NewInstanceReinitializePrototypeInstanceReinitializeByImage : Instantiate InstanceReinitializePrototypeInstanceReinitializeByImage (Generic Model Constructor)
+func (*VpcV1) NewInstanceReinitializePrototypeInstanceReinitializeByImage(image ImageIdentityIntf) (_model *InstanceReinitializePrototypeInstanceReinitializeByImage, err error) {
+ _model = &InstanceReinitializePrototypeInstanceReinitializeByImage{
+ Image: image,
+ }
+ err = core.ValidateStruct(_model, "required parameters")
+ if err != nil {
+ err = core.SDKErrorf(err, "", "model-missing-required", common.GetComponentInfo())
+ }
+ return
+}
+
+func (*InstanceReinitializePrototypeInstanceReinitializeByImage) isaInstanceReinitializePrototype() bool {
+ return true
+}
+
+// UnmarshalInstanceReinitializePrototypeInstanceReinitializeByImage unmarshals an instance of InstanceReinitializePrototypeInstanceReinitializeByImage from the specified map of raw messages.
+func UnmarshalInstanceReinitializePrototypeInstanceReinitializeByImage(m map[string]json.RawMessage, result interface{}) (err error) {
+ obj := new(InstanceReinitializePrototypeInstanceReinitializeByImage)
+ err = core.UnmarshalModel(m, "default_trusted_profile", &obj.DefaultTrustedProfile, UnmarshalInstanceDefaultTrustedProfilePrototype)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "default_trusted_profile-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "keys", &obj.Keys, UnmarshalKeyIdentity)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "keys-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalPrimitive(m, "user_data", &obj.UserData)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "user_data-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "boot_volume_attachment", &obj.BootVolumeAttachment, UnmarshalVolumeAttachmentPrototypeInstanceByImageContext)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "boot_volume_attachment-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "image", &obj.Image, UnmarshalImageIdentity)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "image-error", common.GetComponentInfo())
+ return
+ }
+ reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+ return
+}
+
+// InstanceReinitializePrototypeInstanceReinitializeBySnapshot : Reinitialize an instance by using a snapshot.
+// This model "extends" InstanceReinitializePrototype
+type InstanceReinitializePrototypeInstanceReinitializeBySnapshot struct {
+ // The default trusted profile configuration to use for this virtual server instance. If not specified, the instance
+ // will be reinitialized without a default trusted profile.
+ //
+ // This property's value is used when reinitializing the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
+ // initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
+ DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
+
+ // The public SSH keys for the reinitialized instance. The keys will be made available to the virtual server instance
+ // as cloud-init vendor data. For cloud-init enabled images, the keys will also be added as SSH authorized keys for the
+ // [default user]
+ // (https://cloud.ibm.com/docs/vpc?topic=vpc-vsi_is_connecting_linux#determining-default-user-account).
+ //
+ // For Windows images, only keys with a `type` value of `rsa` must be specified, and one will be selected to encrypt
+ // [the administrator password](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization). Keys are optional for
+ // other images.
+ //
+ // If no keys are specified, the instance will be reinitialized without a key.
+ Keys []KeyIdentityIntf `json:"keys,omitempty"`
+
+ // The [user data](https://cloud.ibm.com/docs/vpc?topic=vpc-user-data) to make available when setting up the virtual
+ // server instance. If not specified, the instance will be reinitialized without user data.
+ UserData *string `json:"user_data,omitempty"`
+
+ // The boot volume attachment for the virtual server instance.
+ BootVolumeAttachment *VolumeAttachmentPrototypeInstanceBySourceSnapshotContext `json:"boot_volume_attachment" validate:"required"`
+}
+
+// NewInstanceReinitializePrototypeInstanceReinitializeBySnapshot : Instantiate InstanceReinitializePrototypeInstanceReinitializeBySnapshot (Generic Model Constructor)
+func (*VpcV1) NewInstanceReinitializePrototypeInstanceReinitializeBySnapshot(bootVolumeAttachment *VolumeAttachmentPrototypeInstanceBySourceSnapshotContext) (_model *InstanceReinitializePrototypeInstanceReinitializeBySnapshot, err error) {
+ _model = &InstanceReinitializePrototypeInstanceReinitializeBySnapshot{
+ BootVolumeAttachment: bootVolumeAttachment,
+ }
+ err = core.ValidateStruct(_model, "required parameters")
+ if err != nil {
+ err = core.SDKErrorf(err, "", "model-missing-required", common.GetComponentInfo())
+ }
+ return
+}
+
+func (*InstanceReinitializePrototypeInstanceReinitializeBySnapshot) isaInstanceReinitializePrototype() bool {
+ return true
+}
+
+// UnmarshalInstanceReinitializePrototypeInstanceReinitializeBySnapshot unmarshals an instance of InstanceReinitializePrototypeInstanceReinitializeBySnapshot from the specified map of raw messages.
+func UnmarshalInstanceReinitializePrototypeInstanceReinitializeBySnapshot(m map[string]json.RawMessage, result interface{}) (err error) {
+ obj := new(InstanceReinitializePrototypeInstanceReinitializeBySnapshot)
+ err = core.UnmarshalModel(m, "default_trusted_profile", &obj.DefaultTrustedProfile, UnmarshalInstanceDefaultTrustedProfilePrototype)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "default_trusted_profile-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "keys", &obj.Keys, UnmarshalKeyIdentity)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "keys-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalPrimitive(m, "user_data", &obj.UserData)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "user_data-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "boot_volume_attachment", &obj.BootVolumeAttachment, UnmarshalVolumeAttachmentPrototypeInstanceBySourceSnapshotContext)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "boot_volume_attachment-error", common.GetComponentInfo())
+ return
+ }
+ reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+ return
+}
+
+// InstanceReinitializePrototypeInstanceReinitializeByVolume : Reinitialize an instance by using a boot volume.
+// This model "extends" InstanceReinitializePrototype
+type InstanceReinitializePrototypeInstanceReinitializeByVolume struct {
+ // The default trusted profile configuration to use for this virtual server instance. If not specified, the instance
+ // will be reinitialized without a default trusted profile.
+ //
+ // This property's value is used when reinitializing the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
+ // initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
+ DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
+
+ // The public SSH keys for the reinitialized instance. The keys will be made available to the virtual server instance
+ // as cloud-init vendor data. For cloud-init enabled images, the keys will also be added as SSH authorized keys for the
+ // [default user]
+ // (https://cloud.ibm.com/docs/vpc?topic=vpc-vsi_is_connecting_linux#determining-default-user-account).
+ //
+ // For Windows images, only keys with a `type` value of `rsa` must be specified, and one will be selected to encrypt
+ // [the administrator password](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization). Keys are optional for
+ // other images.
+ //
+ // If no keys are specified, the instance will be reinitialized without a key.
+ Keys []KeyIdentityIntf `json:"keys,omitempty"`
+
+ // The [user data](https://cloud.ibm.com/docs/vpc?topic=vpc-user-data) to make available when setting up the virtual
+ // server instance. If not specified, the instance will be reinitialized without user data.
+ UserData *string `json:"user_data,omitempty"`
+
+ // The boot volume attachment for the virtual server instance.
+ BootVolumeAttachment *VolumeAttachmentPrototypeInstanceByVolumeContext `json:"boot_volume_attachment" validate:"required"`
+}
+
+// NewInstanceReinitializePrototypeInstanceReinitializeByVolume : Instantiate InstanceReinitializePrototypeInstanceReinitializeByVolume (Generic Model Constructor)
+func (*VpcV1) NewInstanceReinitializePrototypeInstanceReinitializeByVolume(bootVolumeAttachment *VolumeAttachmentPrototypeInstanceByVolumeContext) (_model *InstanceReinitializePrototypeInstanceReinitializeByVolume, err error) {
+ _model = &InstanceReinitializePrototypeInstanceReinitializeByVolume{
+ BootVolumeAttachment: bootVolumeAttachment,
+ }
+ err = core.ValidateStruct(_model, "required parameters")
+ if err != nil {
+ err = core.SDKErrorf(err, "", "model-missing-required", common.GetComponentInfo())
+ }
+ return
+}
+
+func (*InstanceReinitializePrototypeInstanceReinitializeByVolume) isaInstanceReinitializePrototype() bool {
+ return true
+}
+
+// UnmarshalInstanceReinitializePrototypeInstanceReinitializeByVolume unmarshals an instance of InstanceReinitializePrototypeInstanceReinitializeByVolume from the specified map of raw messages.
+func UnmarshalInstanceReinitializePrototypeInstanceReinitializeByVolume(m map[string]json.RawMessage, result interface{}) (err error) {
+ obj := new(InstanceReinitializePrototypeInstanceReinitializeByVolume)
+ err = core.UnmarshalModel(m, "default_trusted_profile", &obj.DefaultTrustedProfile, UnmarshalInstanceDefaultTrustedProfilePrototype)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "default_trusted_profile-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "keys", &obj.Keys, UnmarshalKeyIdentity)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "keys-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalPrimitive(m, "user_data", &obj.UserData)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "user_data-error", common.GetComponentInfo())
+ return
+ }
+ err = core.UnmarshalModel(m, "boot_volume_attachment", &obj.BootVolumeAttachment, UnmarshalVolumeAttachmentPrototypeInstanceByVolumeContext)
+ if err != nil {
+ err = core.SDKErrorf(err, "", "boot_volume_attachment-error", common.GetComponentInfo())
+ return
+ }
+ reflect.ValueOf(result).Elem().Set(reflect.ValueOf(obj))
+ return
+}
+
// InstanceTemplateIdentityByCRN : InstanceTemplateIdentityByCRN struct
// This model "extends" InstanceTemplateIdentity
type InstanceTemplateIdentityByCRN struct {
@@ -138072,8 +138502,8 @@ type InstanceTemplatePrototypeInstanceTemplateByCatalogOffering struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -138091,8 +138521,8 @@ type InstanceTemplatePrototypeInstanceTemplateByCatalogOffering struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -138373,8 +138803,8 @@ type InstanceTemplatePrototypeInstanceTemplateByImage struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -138392,8 +138822,8 @@ type InstanceTemplatePrototypeInstanceTemplateByImage struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -138666,8 +139096,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceSnapshot struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -138685,8 +139115,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceSnapshot struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -138954,8 +139384,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceTemplate struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -138973,8 +139403,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceTemplate struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -139280,8 +139710,8 @@ type InstanceTemplateInstanceByCatalogOfferingInstanceTemplateContext struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -139305,8 +139735,8 @@ type InstanceTemplateInstanceByCatalogOfferingInstanceTemplateContext struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -139611,8 +140041,8 @@ type InstanceTemplateInstanceByImageInstanceTemplateContext struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -139636,8 +140066,8 @@ type InstanceTemplateInstanceByImageInstanceTemplateContext struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -139936,8 +140366,8 @@ type InstanceTemplateInstanceBySourceSnapshotInstanceTemplateContext struct {
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -139961,8 +140391,8 @@ type InstanceTemplateInstanceBySourceSnapshotInstanceTemplateContext struct {
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -164832,8 +165262,8 @@ type InstancePrototypeInstanceByCatalogOfferingInstanceByCatalogOfferingInstance
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -164851,8 +165281,8 @@ type InstancePrototypeInstanceByCatalogOfferingInstanceByCatalogOfferingInstance
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -165116,8 +165546,8 @@ type InstancePrototypeInstanceByCatalogOfferingInstanceByCatalogOfferingInstance
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -165135,8 +165565,8 @@ type InstancePrototypeInstanceByCatalogOfferingInstanceByCatalogOfferingInstance
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -165400,8 +165830,8 @@ type InstancePrototypeInstanceByImageInstanceByImageInstanceByNetworkAttachment
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -165419,8 +165849,8 @@ type InstancePrototypeInstanceByImageInstanceByImageInstanceByNetworkAttachment
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -165685,8 +166115,8 @@ type InstancePrototypeInstanceByImageInstanceByImageInstanceByNetworkInterface s
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -165704,8 +166134,8 @@ type InstancePrototypeInstanceByImageInstanceByImageInstanceByNetworkInterface s
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -165970,8 +166400,8 @@ type InstancePrototypeInstanceBySourceSnapshotInstanceBySourceSnapshotInstanceBy
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -165989,8 +166419,8 @@ type InstancePrototypeInstanceBySourceSnapshotInstanceBySourceSnapshotInstanceBy
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -166247,8 +166677,8 @@ type InstancePrototypeInstanceBySourceSnapshotInstanceBySourceSnapshotInstanceBy
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -166266,8 +166696,8 @@ type InstancePrototypeInstanceBySourceSnapshotInstanceBySourceSnapshotInstanceBy
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -166524,8 +166954,8 @@ type InstancePrototypeInstanceByVolumeInstanceByVolumeInstanceByNetworkAttachmen
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -166543,8 +166973,8 @@ type InstancePrototypeInstanceByVolumeInstanceByVolumeInstanceByNetworkAttachmen
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -166801,8 +167231,8 @@ type InstancePrototypeInstanceByVolumeInstanceByVolumeInstanceByNetworkInterface
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -166820,8 +167250,8 @@ type InstancePrototypeInstanceByVolumeInstanceByVolumeInstanceByNetworkInterface
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -167078,8 +167508,8 @@ type InstanceTemplatePrototypeInstanceTemplateByCatalogOfferingInstanceTemplateB
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -167097,8 +167527,8 @@ type InstanceTemplatePrototypeInstanceTemplateByCatalogOfferingInstanceTemplateB
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -167360,8 +167790,8 @@ type InstanceTemplatePrototypeInstanceTemplateByCatalogOfferingInstanceTemplateB
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -167379,8 +167809,8 @@ type InstanceTemplatePrototypeInstanceTemplateByCatalogOfferingInstanceTemplateB
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -167642,8 +168072,8 @@ type InstanceTemplatePrototypeInstanceTemplateByImageInstanceTemplateByImageInst
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -167661,8 +168091,8 @@ type InstanceTemplatePrototypeInstanceTemplateByImageInstanceTemplateByImageInst
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -167925,8 +168355,8 @@ type InstanceTemplatePrototypeInstanceTemplateByImageInstanceTemplateByImageInst
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -167944,8 +168374,8 @@ type InstanceTemplatePrototypeInstanceTemplateByImageInstanceTemplateByImageInst
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -168208,8 +168638,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceSnapshotInstanceTemplateBy
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -168227,8 +168657,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceSnapshotInstanceTemplateBy
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -168483,8 +168913,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceSnapshotInstanceTemplateBy
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -168502,8 +168932,8 @@ type InstanceTemplatePrototypeInstanceTemplateBySourceSnapshotInstanceTemplateBy
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -168764,8 +169194,8 @@ type InstanceTemplateInstanceByCatalogOfferingInstanceTemplateContextInstanceByC
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -168789,8 +169219,8 @@ type InstanceTemplateInstanceByCatalogOfferingInstanceTemplateContextInstanceByC
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -169064,8 +169494,8 @@ type InstanceTemplateInstanceByCatalogOfferingInstanceTemplateContextInstanceByC
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -169089,8 +169519,8 @@ type InstanceTemplateInstanceByCatalogOfferingInstanceTemplateContextInstanceByC
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -169364,8 +169794,8 @@ type InstanceTemplateInstanceByImageInstanceTemplateContextInstanceByImageInstan
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -169389,8 +169819,8 @@ type InstanceTemplateInstanceByImageInstanceTemplateContextInstanceByImageInstan
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -169665,8 +170095,8 @@ type InstanceTemplateInstanceByImageInstanceTemplateContextInstanceByImageInstan
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -169690,8 +170120,8 @@ type InstanceTemplateInstanceByImageInstanceTemplateContextInstanceByImageInstan
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -169966,8 +170396,8 @@ type InstanceTemplateInstanceBySourceSnapshotInstanceTemplateContextInstanceBySo
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -169991,8 +170421,8 @@ type InstanceTemplateInstanceBySourceSnapshotInstanceTemplateContextInstanceBySo
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
@@ -170267,8 +170697,8 @@ type InstanceTemplateInstanceBySourceSnapshotInstanceTemplateContextInstanceBySo
// The default trusted profile configuration to use for this virtual server instance
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
DefaultTrustedProfile *InstanceDefaultTrustedProfilePrototype `json:"default_trusted_profile,omitempty"`
@@ -170292,8 +170722,8 @@ type InstanceTemplateInstanceBySourceSnapshotInstanceTemplateContextInstanceBySo
// no keys are specified, the instance will be inaccessible unless the specified image provides another means of
// access.
//
- // This property's value is used when provisioning the virtual server instance, but not subsequently managed.
- // Accordingly, it is reflected as an [instance
+ // This property's value is used when provisioning the virtual server instance, and can only be changed by
+ // reinitializing the instance. Accordingly, it is reflected as an [instance
// initialization](https://cloud.ibm.com/apidocs/vpc#get-instance-initialization) property.
Keys []KeyIdentityIntf `json:"keys,omitempty"`
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go
index 5b940e386..93b3d00e5 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/aws/go_module_metadata.go
@@ -3,4 +3,4 @@
package aws
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.43.3"
+const goModuleVersion = "1.43.4"
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/aws/transport/http/client.go b/vendor/github.com/aws/aws-sdk-go-v2/aws/transport/http/client.go
index 49cc31205..94094ec2c 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/aws/transport/http/client.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/aws/transport/http/client.go
@@ -2,6 +2,7 @@ package http
import (
"context"
+ "crypto/fips140"
"crypto/tls"
"net"
"net/http"
@@ -27,6 +28,19 @@ var (
// Default to TLS 1.2 for all HTTPS requests.
DefaultHTTPTransportTLSMinVersion uint16 = tls.VersionTLS12
+
+ // DefaultHTTPTransportTLSCurvePreferencesFIPS is the elliptic curve preference
+ // list applied to the default transport when the FIPS 140-3 module is active.
+ //
+ // Go's default preferences lead with X25519, which crypto/ecdh rejects under
+ // GODEBUG=fips140=only, failing every TLS handshake the SDK attempts. Only the
+ // NIST curves are FIPS-approved, so restricting to them keeps the default
+ // client usable in FIPS deployments.
+ DefaultHTTPTransportTLSCurvePreferencesFIPS = []tls.CurveID{
+ tls.CurveP256,
+ tls.CurveP384,
+ tls.CurveP521,
+ }
)
// Timeouts for net.Dialer's network connection.
@@ -178,6 +192,16 @@ func defaultDialer() *net.Dialer {
}
}
+// defaultTLSCurvePreferences returns the curve preferences for the default
+// transport. Outside FIPS mode it returns nil so Go's own defaults apply,
+// preserving X25519 and the post-quantum X25519MLKEM768 hybrid.
+func defaultTLSCurvePreferences(fipsEnabled bool) []tls.CurveID {
+ if !fipsEnabled {
+ return nil
+ }
+ return DefaultHTTPTransportTLSCurvePreferencesFIPS
+}
+
func defaultHTTPTransport() *http.Transport {
dialer := defaultDialer()
@@ -192,7 +216,8 @@ func defaultHTTPTransport() *http.Transport {
ExpectContinueTimeout: DefaultHTTPTransportExpectContinueTimeout,
ForceAttemptHTTP2: true,
TLSClientConfig: &tls.Config{
- MinVersion: DefaultHTTPTransportTLSMinVersion,
+ MinVersion: DefaultHTTPTransportTLSMinVersion,
+ CurvePreferences: defaultTLSCurvePreferences(fips140.Enabled()),
},
}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md
index 12fedd913..3ae97e958 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md
+++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/CHANGELOG.md
@@ -1,3 +1,7 @@
+# v1.4.35 (2026-08-05)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
# v1.4.34 (2026-07-31.2)
* **Dependency Update**: Updated to the latest SDK module versions
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go
index 1afd96dbf..ebe849c98 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/configsources/go_module_metadata.go
@@ -3,4 +3,4 @@
package configsources
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.4.34"
+const goModuleVersion = "1.4.35"
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md
index 5ec077fe2..a558eb3cd 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md
+++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/CHANGELOG.md
@@ -1,3 +1,7 @@
+# v2.7.35 (2026-08-05)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
# v2.7.34 (2026-07-31.2)
* **Dependency Update**: Updated to the latest SDK module versions
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go
index d1e101dc3..c40f005ff 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/internal/endpoints/v2/go_module_metadata.go
@@ -3,4 +3,4 @@
package endpoints
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "2.7.34"
+const goModuleVersion = "2.7.35"
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md
index c2b71c54b..46e3dbfbd 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/CHANGELOG.md
@@ -1,3 +1,11 @@
+# v1.319.1 (2026-08-05)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
+# v1.319.0 (2026-08-04)
+
+* **Feature**: Amazon EC2 now supports Application Status Checks, a new status check that monitors your application's health through configurable HTTP(S) paths and ports, so you can detect and automatically respond to application-level impairments.
+
# v1.318.1 (2026-07-31.2)
* **Dependency Update**: Updated to the latest SDK module versions
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_AssociateApplicationStatusCheck.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_AssociateApplicationStatusCheck.go
new file mode 100644
index 000000000..07241cc73
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_AssociateApplicationStatusCheck.go
@@ -0,0 +1,185 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Associates an application status check with instances or [tags]. Once you create an
+// association, health monitoring automatically begins for the specified instances
+// or for instances that match the specified tags. The following rules apply:
+//
+// - You must specify either TargetTagAssociations or InstanceIds , but not both.
+// Specifying both results in an InvalidParameterCombination error.
+//
+// - The application status check must already exist and belong to your account.
+//
+// - Tag keys must not be blank.
+//
+// - Maximum 50 tag associations per application status check.
+//
+// - Use DisassociateApplicationStatusCheck to remove associations.
+//
+// - When you associate [tags], the application status check automatically monitors
+// all current and future instances that have the specified tags.
+//
+// [tags]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html
+func (c *Client) AssociateApplicationStatusCheck(ctx context.Context, params *AssociateApplicationStatusCheckInput, optFns ...func(*Options)) (*AssociateApplicationStatusCheckOutput, error) {
+ if params == nil {
+ params = &AssociateApplicationStatusCheckInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "AssociateApplicationStatusCheck", params, optFns, c.addOperationAssociateApplicationStatusCheckMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*AssociateApplicationStatusCheckOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type AssociateApplicationStatusCheckInput struct {
+
+ // The ID of the application status check to associate.
+ //
+ // This member is required.
+ ApplicationStatusCheckId *string
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The IDs of the instances to associate with the application status check.
+ InstanceIds []string
+
+ // The [tags] to associate the application status check with. Each tag is a key-value
+ // pair. When you associate tags, the application status check automatically
+ // monitors all instances that have the specified tags.
+ //
+ // [tags]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html
+ TargetTagAssociations []types.CustomTagKeyValueRequestPair
+
+ noSmithyDocumentSerde
+}
+
+type AssociateApplicationStatusCheckOutput struct {
+
+ // The associations that were successfully created.
+ SuccessfulResults []types.SuccessfulAssociationResponseObject
+
+ // The associations that failed to be created.
+ UnsuccessfulResults []types.UnsuccessfulAssociationResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationAssociateApplicationStatusCheckMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpAssociateApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpAssociateApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opAssociateApplicationStatusCheckMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addOpAssociateApplicationStatusCheckValidationMiddleware(stack); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "AssociateApplicationStatusCheck"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpAssociateApplicationStatusCheck struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpAssociateApplicationStatusCheck) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpAssociateApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*AssociateApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *AssociateApplicationStatusCheckInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opAssociateApplicationStatusCheckMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpAssociateApplicationStatusCheck{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_BundleInstance.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_BundleInstance.go
index fd4ba3801..d6eee47e3 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_BundleInstance.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_BundleInstance.go
@@ -14,8 +14,9 @@ import (
// During bundling, only the root device volume (C:\) is bundled. Data on other
// instance store volumes is not preserved.
//
-// This action is no longer supported. To create an AMI, use [CreateImage]. For more
-// information, see [Create an Amazon EBS-backed AMI]in the Amazon EC2 User Guide.
+// BundleInstance is no longer supported. To create an AMI, use [CreateImage] instead. For more
+// information about creating an Amazon EBS-backed AMI, see [Create an Amazon EBS-backed AMI]in the Amazon EC2 User
+// Guide.
//
// [Create an Amazon EBS-backed AMI]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html
// [CreateImage]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateImage.html
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CancelBundleTask.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CancelBundleTask.go
index 5e16083c1..c2405f52f 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CancelBundleTask.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CancelBundleTask.go
@@ -10,6 +10,11 @@ import (
)
// Cancels a bundling operation for an instance store-backed Windows instance.
+//
+// CancelBundleTask is no longer supported because [BundleInstance], the operation it cancels, is
+// no longer supported.
+//
+// [BundleInstance]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_BundleInstance.html
func (c *Client) CancelBundleTask(ctx context.Context, params *CancelBundleTaskInput, optFns ...func(*Options)) (*CancelBundleTaskOutput, error) {
if params == nil {
params = &CancelBundleTaskInput{}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateApplicationStatusCheck.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateApplicationStatusCheck.go
new file mode 100644
index 000000000..cbe1ea424
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateApplicationStatusCheck.go
@@ -0,0 +1,239 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Creates an application status check for monitoring the health of applications
+// running on your instances. You can configure the protocol, port, path, and
+// thresholds for the health check. The following rules apply:
+//
+// - You can create a maximum of 50 application status checks per account.
+//
+// - Health checks do not start until you associate the check with instances or
+// tags using AssociateApplicationStatusCheck .
+//
+// - The Timeout value must be less than the Interval value.
+//
+// - The Path must start with a forward slash ( / ). Default: / .
+//
+// - If you do not specify Aggregation , it defaults to included , which means
+// the check contributes to the instance-level application status.
+//
+// - Default values: Interval is 60 seconds, Timeout is 6 seconds,
+// FailureThreshold is 2, SuccessThreshold is 5, StatusCodeMatcher is 200 ,
+// InitializationGracePeriodSeconds is 300 seconds.
+//
+// - You can tag the application status check during creation. For more
+// information, see [Tag your Amazon EC2 resources].
+//
+// [Tag your Amazon EC2 resources]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html
+func (c *Client) CreateApplicationStatusCheck(ctx context.Context, params *CreateApplicationStatusCheckInput, optFns ...func(*Options)) (*CreateApplicationStatusCheckOutput, error) {
+ if params == nil {
+ params = &CreateApplicationStatusCheckInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "CreateApplicationStatusCheck", params, optFns, c.addOperationCreateApplicationStatusCheckMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*CreateApplicationStatusCheckOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type CreateApplicationStatusCheckInput struct {
+
+ // The port to use for the health check. Valid values: 1 to 65535.
+ //
+ // This member is required.
+ Port *int32
+
+ // The protocol to use for the health check. Valid values: http | https .
+ //
+ // This member is required.
+ Protocol types.NetworkProtocolEnum
+
+ // The aggregation setting for the application status check. When set to included ,
+ // the result of this check contributes to the instance-level application status
+ // reported by DescribeApplicationStatus . When set to excluded , the check runs
+ // independently and does not affect the instance-level status. Valid values:
+ // included | excluded .
+ Aggregation types.AggregationStatusEnum
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // The index of the network device to use for the health check. The value must be
+ // greater than or equal to 0.
+ DeviceIndex *int32
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The number of consecutive failed health checks before the application status is
+ // considered impaired. The value must be greater than 0.
+ FailureThreshold *int32
+
+ // The health check paths to use for the application status check. Health check
+ // paths define the network path from a source subnet to one or more destination
+ // subnets for cross-Availability Zone or Availability Zone to Local Zone health
+ // checking. If omitted, health checks are performed in the same subnet as the
+ // instance.
+ HealthCheckPaths []types.HealthCheckPathRequestObject
+
+ // The number of seconds to wait before starting health checks after an instance
+ // is launched. Valid values: 1 to 600.
+ InitializationGracePeriodSeconds *int32
+
+ // The interval, in seconds, between health checks. Valid value: 60.
+ Interval *int32
+
+ // The IP scope to use for the health check. Valid value: private .
+ IpScope types.IpScopeEnum
+
+ // The IP version to use for the health check. Valid values: ipv4 and ipv6 .
+ IpVersion types.IpVersionEnum
+
+ // The URL path to use for the health check HTTP request (for example, /health or
+ // /status ).
+ Path *string
+
+ // The HTTP status codes that indicate a successful health check response. Specify
+ // a comma-separated list of individual status codes or ranges, for example,
+ // 200,202,300-399 . For a range, the first value must be less than the second
+ // value. Maximum length: 64 characters. Default: 200 .
+ StatusCodeMatcher *string
+
+ // The number of consecutive successful health checks before the application
+ // status is considered healthy. The value must be greater than 0.
+ SuccessThreshold *int32
+
+ // The tags to apply to the application status check.
+ TagSpecifications []types.TagSpecification
+
+ // The amount of time, in seconds, to wait for a health check response before
+ // considering it failed. Valid values: 1 to 30. The value must be less than
+ // Interval .
+ Timeout *int32
+
+ noSmithyDocumentSerde
+}
+
+type CreateApplicationStatusCheckOutput struct {
+
+ // Information about the application status check.
+ ApplicationStatusCheck *types.ApplicationStatusCheckResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationCreateApplicationStatusCheckMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpCreateApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpCreateApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opCreateApplicationStatusCheckMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addOpCreateApplicationStatusCheckValidationMiddleware(stack); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "CreateApplicationStatusCheck"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpCreateApplicationStatusCheck struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpCreateApplicationStatusCheck) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpCreateApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*CreateApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *CreateApplicationStatusCheckInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opCreateApplicationStatusCheckMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpCreateApplicationStatusCheck{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateFlowLogs.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateFlowLogs.go
index 8bc96d595..8ce46b258 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateFlowLogs.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateFlowLogs.go
@@ -46,7 +46,7 @@ type CreateFlowLogsInput struct {
// The IDs of the resources to monitor. For example, if the resource type is VPC ,
// specify the IDs of the VPCs.
//
- // Constraints: Maximum of 25 for transit gateway resource types. Maximum of 1000
+ // Constraints: Maximum of 25 for transit gateway resource types. Maximum of 300
// for the other resource types.
//
// This member is required.
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go
index bbb2ece4e..39377aab8 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_CreateSecondaryNetwork.go
@@ -31,12 +31,6 @@ func (c *Client) CreateSecondaryNetwork(ctx context.Context, params *CreateSecon
type CreateSecondaryNetworkInput struct {
- // The IPv4 CIDR block for the secondary network. The CIDR block size must be
- // between /12 and /28.
- //
- // This member is required.
- Ipv4CidrBlock *string
-
// The type of secondary network.
//
// This member is required.
@@ -54,6 +48,10 @@ type CreateSecondaryNetworkInput struct {
// UnauthorizedOperation .
DryRun *bool
+ // The IPv4 CIDR block for the secondary network. The CIDR block size must be
+ // between /12 and /28.
+ Ipv4CidrBlock *string
+
// The tags to assign to the secondary network.
TagSpecifications []types.TagSpecification
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteApplicationStatusCheck.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteApplicationStatusCheck.go
new file mode 100644
index 000000000..36ca3d321
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DeleteApplicationStatusCheck.go
@@ -0,0 +1,158 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Deletes an application status check. The following rules apply:
+//
+// - Deleting a check automatically removes all of its associations.
+//
+// - Use DescribeApplicationStatusChecks to view existing checks before deleting.
+func (c *Client) DeleteApplicationStatusCheck(ctx context.Context, params *DeleteApplicationStatusCheckInput, optFns ...func(*Options)) (*DeleteApplicationStatusCheckOutput, error) {
+ if params == nil {
+ params = &DeleteApplicationStatusCheckInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "DeleteApplicationStatusCheck", params, optFns, c.addOperationDeleteApplicationStatusCheckMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*DeleteApplicationStatusCheckOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type DeleteApplicationStatusCheckInput struct {
+
+ // The ID of the application status check to delete.
+ //
+ // This member is required.
+ ApplicationStatusCheckId *string
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ noSmithyDocumentSerde
+}
+
+type DeleteApplicationStatusCheckOutput struct {
+
+ // Information about the deleted application status check.
+ ApplicationStatusCheck *types.ApplicationStatusCheckResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationDeleteApplicationStatusCheckMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpDeleteApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpDeleteApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opDeleteApplicationStatusCheckMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addOpDeleteApplicationStatusCheckValidationMiddleware(stack); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "DeleteApplicationStatusCheck"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpDeleteApplicationStatusCheck struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpDeleteApplicationStatusCheck) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpDeleteApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*DeleteApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *DeleteApplicationStatusCheckInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opDeleteApplicationStatusCheckMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpDeleteApplicationStatusCheck{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatus.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatus.go
new file mode 100644
index 000000000..1ba963786
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatus.go
@@ -0,0 +1,140 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Describes the application status for the specified instances. Returns the
+// aggregated application health status for each instance. The following rules
+// apply:
+//
+// - The instance-level status is derived from all application status checks
+// with the aggregation setting set to included .
+//
+// - Use DescribeApplicationStatusChecks to view the configuration of individual
+// checks.
+//
+// - Use EnableApplicationStatusCheckSuppression to temporarily suppress health
+// check results from affecting the instance-level status.
+func (c *Client) DescribeApplicationStatus(ctx context.Context, params *DescribeApplicationStatusInput, optFns ...func(*Options)) (*DescribeApplicationStatusOutput, error) {
+ if params == nil {
+ params = &DescribeApplicationStatusInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "DescribeApplicationStatus", params, optFns, c.addOperationDescribeApplicationStatusMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*DescribeApplicationStatusOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type DescribeApplicationStatusInput struct {
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The filters.
+ //
+ // - availability-zone-id – The ID of the Availability Zone.
+ //
+ // - status – The instance-level application status. For valid values and their
+ // meanings, see ApplicationStatus .
+ Filters []types.Filter
+
+ // The IDs of the instances for which to describe application status.
+ InstanceIds []string
+
+ // The maximum number of items to return for this request. To get the next page of
+ // items, make another request with the token returned in the output. For more
+ // information, see [Pagination].
+ //
+ // [Pagination]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination
+ MaxResults *int32
+
+ // The token returned from a previous paginated request. Pagination continues from
+ // the end of the items returned by the previous request.
+ NextToken *string
+
+ noSmithyDocumentSerde
+}
+
+type DescribeApplicationStatusOutput struct {
+
+ // The application statuses for the specified instances.
+ ApplicationStatuses *types.ApplicationStatusesResponseType
+
+ // The token to include in another request to get the next page of items. This
+ // value is null when there are no more items to return.
+ NextToken *string
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationDescribeApplicationStatusMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeApplicationStatus{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeApplicationStatus{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "DescribeApplicationStatus"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatusCheckAssociations.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatusCheckAssociations.go
new file mode 100644
index 000000000..a8344d11d
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatusCheckAssociations.go
@@ -0,0 +1,137 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Describes the associations for one or more application status checks. For more
+// information, see [Application status checks]. To avoid timeouts and retrieve complete results, use the
+// pagination parameters.
+//
+// The order of the elements in the response, including those within nested
+// structures, might vary.
+//
+// [Application status checks]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/monitoring-application-status-checks.html
+func (c *Client) DescribeApplicationStatusCheckAssociations(ctx context.Context, params *DescribeApplicationStatusCheckAssociationsInput, optFns ...func(*Options)) (*DescribeApplicationStatusCheckAssociationsOutput, error) {
+ if params == nil {
+ params = &DescribeApplicationStatusCheckAssociationsInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "DescribeApplicationStatusCheckAssociations", params, optFns, c.addOperationDescribeApplicationStatusCheckAssociationsMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*DescribeApplicationStatusCheckAssociationsOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type DescribeApplicationStatusCheckAssociationsInput struct {
+
+ // The IDs of the application status checks for which to describe associations.
+ ApplicationStatusCheckIds []string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The filters to use to limit the results.
+ //
+ // - association-type – The type of association. Valid values: tag and
+ // instance-id .
+ Filters []types.Filter
+
+ // The maximum number of items to return for this request. To get the next page of
+ // items, make another request with the token returned in the output. For more
+ // information, see [Pagination].
+ //
+ // [Pagination]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination
+ MaxResults *int32
+
+ // The token returned from a previous paginated request. Pagination continues from
+ // the end of the items returned by the previous request.
+ NextToken *string
+
+ noSmithyDocumentSerde
+}
+
+type DescribeApplicationStatusCheckAssociationsOutput struct {
+
+ // The associations for the specified application status checks.
+ Associations []types.ApplicationStatusCheckAssociationObject
+
+ // The token to include in another request to get the next page of items. This
+ // value is null when there are no more items to return.
+ NextToken *string
+
+ // The tags associated with the application status checks.
+ Tags []types.Tag
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationDescribeApplicationStatusCheckAssociationsMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeApplicationStatusCheckAssociations{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeApplicationStatusCheckAssociations{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "DescribeApplicationStatusCheckAssociations"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatusChecks.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatusChecks.go
new file mode 100644
index 000000000..8ca1c7b3c
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeApplicationStatusChecks.go
@@ -0,0 +1,138 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Describes one or more application status checks. Returns configuration details
+// for your application status checks, including protocol, port, path, thresholds,
+// and associations. The following rules apply:
+//
+// - If you do not specify any application status check IDs, all checks in your
+// account are returned.
+//
+// - Use DescribeApplicationStatus to see the actual health status of instances.
+func (c *Client) DescribeApplicationStatusChecks(ctx context.Context, params *DescribeApplicationStatusChecksInput, optFns ...func(*Options)) (*DescribeApplicationStatusChecksOutput, error) {
+ if params == nil {
+ params = &DescribeApplicationStatusChecksInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "DescribeApplicationStatusChecks", params, optFns, c.addOperationDescribeApplicationStatusChecksMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*DescribeApplicationStatusChecksOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type DescribeApplicationStatusChecksInput struct {
+
+ // The IDs of the application status checks to describe.
+ ApplicationStatusCheckIds []string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The filters.
+ //
+ // - aggregation – The aggregation setting. Valid values: included and excluded .
+ Filters []types.Filter
+
+ // Specifies whether to include recently deleted application status checks that
+ // remain available during the deletion grace period. If you omit this parameter or
+ // set it to false , the response includes only active checks.
+ IncludeAll *bool
+
+ // The maximum number of items to return for this request. To get the next page of
+ // items, make another request with the token returned in the output. For more
+ // information, see [Pagination].
+ //
+ // [Pagination]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Query-Requests.html#api-pagination
+ MaxResults *int32
+
+ // The token returned from a previous paginated request. Pagination continues from
+ // the end of the items returned by the previous request.
+ NextToken *string
+
+ noSmithyDocumentSerde
+}
+
+type DescribeApplicationStatusChecksOutput struct {
+
+ // Information about the application status checks.
+ ApplicationStatusChecks []types.ApplicationStatusCheckResponseObject
+
+ // The token to include in another request to get the next page of items. This
+ // value is null when there are no more items to return.
+ NextToken *string
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationDescribeApplicationStatusChecksMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpDescribeApplicationStatusChecks{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpDescribeApplicationStatusChecks{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "DescribeApplicationStatusChecks"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityReservationTopology.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityReservationTopology.go
index 88b36d514..990a857fa 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityReservationTopology.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeCapacityReservationTopology.go
@@ -52,7 +52,7 @@ type DescribeCapacityReservationTopologyInput struct {
//
// Default: Describes all your Capacity Reservations.
//
- // Constraints: Maximum 100 explicitly specified Capacity Reservation IDs.
+ // Constraints: Maximum 10 explicitly specified Capacity Reservation IDs.
CapacityReservationIds []string
// Checks whether you have the required permissions for the operation, without
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeInstanceStatus.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeInstanceStatus.go
index a6c6daa8d..9c71d3b07 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeInstanceStatus.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DescribeInstanceStatus.go
@@ -25,6 +25,10 @@ import (
// to identify hardware and software issues. For more information, see [Status checks for your instances]and [Troubleshoot instances with failed status checks]in
// the Amazon EC2 User Guide.
//
+// - Application status checks - Amazon EC2 reports application-level health
+// status for instances, indicating whether applications running on the instance
+// are functioning properly.
+//
// - Scheduled events - Amazon EC2 can schedule events (such as reboot, stop, or
// terminate) for your instances related to hardware issues, software updates, or
// system maintenance. For more information, see [Scheduled events for your instances]in the Amazon EC2 User Guide.
@@ -122,6 +126,9 @@ type DescribeInstanceStatusInput struct {
//
// - attached-ebs-status.status - The status of the attached EBS volume for the
// instance ( ok | impaired | initializing | insufficient-data | not-applicable ).
+ //
+ // - application-status.status - The application status of the instance ( ok |
+ // impaired | initializing | insufficient-data | not-applicable ).
Filters []types.Filter
// When true , includes the health status for all instances. When false , includes
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DisableApplicationStatusCheckSuppression.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DisableApplicationStatusCheckSuppression.go
new file mode 100644
index 000000000..626b70cfa
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DisableApplicationStatusCheckSuppression.go
@@ -0,0 +1,156 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Disables suppression of application status checks for the specified instances.
+// After suppression is disabled, health check results resume affecting the
+// instance-level application status. You can specify a maximum of 100 instance IDs
+// per request.
+func (c *Client) DisableApplicationStatusCheckSuppression(ctx context.Context, params *DisableApplicationStatusCheckSuppressionInput, optFns ...func(*Options)) (*DisableApplicationStatusCheckSuppressionOutput, error) {
+ if params == nil {
+ params = &DisableApplicationStatusCheckSuppressionInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "DisableApplicationStatusCheckSuppression", params, optFns, c.addOperationDisableApplicationStatusCheckSuppressionMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*DisableApplicationStatusCheckSuppressionOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type DisableApplicationStatusCheckSuppressionInput struct {
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The IDs of the instances for which to disable application status check
+ // suppression.
+ InstanceIds []string
+
+ noSmithyDocumentSerde
+}
+
+type DisableApplicationStatusCheckSuppressionOutput struct {
+
+ // The instances for which suppression was successfully disabled.
+ SuccessfulResults []types.SuccessfulSuppressionResponseObject
+
+ // The instances for which suppression failed to be disabled.
+ UnsuccessfulResults []types.UnsuccessfulSuppressionResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationDisableApplicationStatusCheckSuppressionMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpDisableApplicationStatusCheckSuppression{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpDisableApplicationStatusCheckSuppression{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opDisableApplicationStatusCheckSuppressionMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "DisableApplicationStatusCheckSuppression"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpDisableApplicationStatusCheckSuppression struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpDisableApplicationStatusCheckSuppression) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpDisableApplicationStatusCheckSuppression) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*DisableApplicationStatusCheckSuppressionInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *DisableApplicationStatusCheckSuppressionInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opDisableApplicationStatusCheckSuppressionMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpDisableApplicationStatusCheckSuppression{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DisassociateApplicationStatusCheck.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DisassociateApplicationStatusCheck.go
new file mode 100644
index 000000000..7d19b52ec
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_DisassociateApplicationStatusCheck.go
@@ -0,0 +1,177 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Disassociates an application status check from instances or [tags]. After
+// disassociation, health monitoring stops for the affected instances. The
+// following rules apply:
+//
+// - You must specify either TargetTagAssociations or InstanceIds , but not both.
+// Specifying both results in an InvalidParameterCombination error.
+//
+// - The application status check must already exist and belong to your account.
+//
+// - Tag keys must not be blank.
+//
+// [tags]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html
+func (c *Client) DisassociateApplicationStatusCheck(ctx context.Context, params *DisassociateApplicationStatusCheckInput, optFns ...func(*Options)) (*DisassociateApplicationStatusCheckOutput, error) {
+ if params == nil {
+ params = &DisassociateApplicationStatusCheckInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "DisassociateApplicationStatusCheck", params, optFns, c.addOperationDisassociateApplicationStatusCheckMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*DisassociateApplicationStatusCheckOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type DisassociateApplicationStatusCheckInput struct {
+
+ // The ID of the application status check to disassociate.
+ //
+ // This member is required.
+ ApplicationStatusCheckId *string
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The IDs of the instances to disassociate from the application status check.
+ InstanceIds []string
+
+ // The [tags] to disassociate from the application status check. Specify the same
+ // key-value pairs that were used during association.
+ //
+ // [tags]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html
+ TargetTagAssociations []types.CustomTagKeyValueRequestPair
+
+ noSmithyDocumentSerde
+}
+
+type DisassociateApplicationStatusCheckOutput struct {
+
+ // The associations that were successfully removed.
+ SuccessfulResults []types.SuccessfulAssociationResponseObject
+
+ // The associations that failed to be removed.
+ UnsuccessfulResults []types.UnsuccessfulAssociationResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationDisassociateApplicationStatusCheckMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpDisassociateApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpDisassociateApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opDisassociateApplicationStatusCheckMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addOpDisassociateApplicationStatusCheckValidationMiddleware(stack); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "DisassociateApplicationStatusCheck"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpDisassociateApplicationStatusCheck struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpDisassociateApplicationStatusCheck) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpDisassociateApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*DisassociateApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *DisassociateApplicationStatusCheckInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opDisassociateApplicationStatusCheckMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpDisassociateApplicationStatusCheck{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_EnableApplicationStatusCheckSuppression.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_EnableApplicationStatusCheckSuppression.go
new file mode 100644
index 000000000..a1b28a9c4
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_EnableApplicationStatusCheckSuppression.go
@@ -0,0 +1,167 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Suppresses application status checks for the specified instances. While
+// suppressed, health checks continue to run but do not affect the instance-level
+// application status. The following rules apply:
+//
+// - Maximum 100 instance IDs per request.
+//
+// - Use DisableApplicationStatusCheckSuppression to resume normal health check
+// reporting.
+//
+// - If you do not specify DurationSeconds , suppression continues indefinitely
+// until you call DisableApplicationStatusCheckSuppression .
+func (c *Client) EnableApplicationStatusCheckSuppression(ctx context.Context, params *EnableApplicationStatusCheckSuppressionInput, optFns ...func(*Options)) (*EnableApplicationStatusCheckSuppressionOutput, error) {
+ if params == nil {
+ params = &EnableApplicationStatusCheckSuppressionInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "EnableApplicationStatusCheckSuppression", params, optFns, c.addOperationEnableApplicationStatusCheckSuppressionMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*EnableApplicationStatusCheckSuppressionOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type EnableApplicationStatusCheckSuppressionInput struct {
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The duration, in seconds, for which to suppress application status checks. If
+ // omitted, the application status check is suppressed indefinitely until you call
+ // DisableApplicationStatusCheckSuppression .
+ DurationSeconds *int32
+
+ // The IDs of the instances for which to suppress application status checks.
+ InstanceIds []string
+
+ noSmithyDocumentSerde
+}
+
+type EnableApplicationStatusCheckSuppressionOutput struct {
+
+ // The instances for which suppression was successfully enabled.
+ SuccessfulResults []types.SuccessfulSuppressionResponseObject
+
+ // The instances for which suppression failed to be enabled.
+ UnsuccessfulResults []types.UnsuccessfulSuppressionResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationEnableApplicationStatusCheckSuppressionMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpEnableApplicationStatusCheckSuppression{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpEnableApplicationStatusCheckSuppression{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opEnableApplicationStatusCheckSuppressionMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "EnableApplicationStatusCheckSuppression"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpEnableApplicationStatusCheckSuppression struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpEnableApplicationStatusCheckSuppression) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpEnableApplicationStatusCheckSuppression) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*EnableApplicationStatusCheckSuppressionInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *EnableApplicationStatusCheckSuppressionInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opEnableApplicationStatusCheckSuppressionMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpEnableApplicationStatusCheckSuppression{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyApplicationStatusCheck.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyApplicationStatusCheck.go
new file mode 100644
index 000000000..23febcaa5
--- /dev/null
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ModifyApplicationStatusCheck.go
@@ -0,0 +1,216 @@
+// Code generated by smithy-go-codegen DO NOT EDIT.
+
+package ec2
+
+import (
+ "context"
+ "fmt"
+ "github.com/aws/aws-sdk-go-v2/service/ec2/types"
+ "github.com/aws/smithy-go/middleware"
+ smithyhttp "github.com/aws/smithy-go/transport/http"
+)
+
+// Modifies an existing application status check. You can update the protocol,
+// port, path, thresholds, and other configuration settings. The following rules
+// apply:
+//
+// - The application status check must exist and belong to your account.
+//
+// - Changes take effect on the next health check interval.
+func (c *Client) ModifyApplicationStatusCheck(ctx context.Context, params *ModifyApplicationStatusCheckInput, optFns ...func(*Options)) (*ModifyApplicationStatusCheckOutput, error) {
+ if params == nil {
+ params = &ModifyApplicationStatusCheckInput{}
+ }
+
+ result, metadata, err := c.invokeOperation(ctx, "ModifyApplicationStatusCheck", params, optFns, c.addOperationModifyApplicationStatusCheckMiddlewares)
+ if err != nil {
+ return nil, err
+ }
+
+ out := result.(*ModifyApplicationStatusCheckOutput)
+ out.ResultMetadata = metadata
+ return out, nil
+}
+
+type ModifyApplicationStatusCheckInput struct {
+
+ // The ID of the application status check to modify.
+ //
+ // This member is required.
+ ApplicationStatusCheckId *string
+
+ // The aggregation setting for the application status check. When set to included ,
+ // the result of this check contributes to the instance-level application status
+ // reported by DescribeApplicationStatus . When set to excluded , the check runs
+ // independently and does not affect the instance-level status. Valid values:
+ // included | excluded .
+ Aggregation types.AggregationStatusEnum
+
+ // Unique, case-sensitive identifier that you provide to ensure the idempotency of
+ // the request. For more information, see [Ensuring idempotency].
+ //
+ // [Ensuring idempotency]: https://docs.aws.amazon.com/AWSEC2/latest/APIReference/Run_Instance_Idempotency.html
+ ClientToken *string
+
+ // The index of the network device to use for the health check. The value must be
+ // greater than or equal to 0.
+ DeviceIndex *int32
+
+ // Checks whether you have the required permissions for the operation, without
+ // actually making the request, and provides an error response. If you have the
+ // required permissions, the error response is DryRunOperation . Otherwise, it is
+ // UnauthorizedOperation .
+ DryRun *bool
+
+ // The number of consecutive failed health checks before the application status is
+ // considered impaired. The value must be greater than 0.
+ FailureThreshold *int32
+
+ // The health check paths to use for the application status check.
+ HealthCheckPaths []types.HealthCheckPathRequestObject
+
+ // The number of seconds to wait before starting health checks after an instance
+ // is launched. Valid values: 1 to 600.
+ InitializationGracePeriodSeconds *int32
+
+ // The interval, in seconds, between health checks. Valid value: 60.
+ Interval *int32
+
+ // The IP scope to use for the health check. Valid value: private .
+ IpScope types.IpScopeEnum
+
+ // The IP version to use for the health check. Valid values: ipv4 and ipv6 .
+ IpVersion types.IpVersionEnum
+
+ // The URL path to use for the health check HTTP request (for example, /health or
+ // /status ).
+ Path *string
+
+ // The port to use for the health check. Valid values: 1 to 65535.
+ Port *int32
+
+ // The protocol to use for the health check. Valid values: http | https .
+ Protocol types.NetworkProtocolEnum
+
+ // The HTTP status codes that indicate a successful health check response. Specify
+ // a comma-separated list of individual status codes or ranges, for example,
+ // 200,202,300-399 . For a range, the first value must be less than the second
+ // value. Maximum length: 64 characters.
+ StatusCodeMatcher *string
+
+ // The number of consecutive successful health checks before the application
+ // status is considered healthy. The value must be greater than 0.
+ SuccessThreshold *int32
+
+ // The amount of time, in seconds, to wait for a health check response before
+ // considering it failed. Valid values: 1 to 30. The value must be less than
+ // Interval .
+ Timeout *int32
+
+ noSmithyDocumentSerde
+}
+
+type ModifyApplicationStatusCheckOutput struct {
+
+ // Information about the modified application status check.
+ ApplicationStatusCheck *types.ApplicationStatusCheckResponseObject
+
+ // Metadata pertaining to the operation's result.
+ ResultMetadata middleware.Metadata
+
+ noSmithyDocumentSerde
+}
+
+func (c *Client) addOperationModifyApplicationStatusCheckMiddlewares(stack *middleware.Stack, options Options) (err error) {
+ err = stack.Serialize.Add(&awsEc2query_serializeOpModifyApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+ err = stack.Deserialize.Add(&awsEc2query_deserializeOpModifyApplicationStatusCheck{}, middleware.After)
+ if err != nil {
+ return err
+ }
+
+ if err = addlegacyEndpointContextSetter(stack, options); err != nil {
+ return err
+ }
+ if err = addComputeContentLength(stack); err != nil {
+ return err
+ }
+ if err = addResolveEndpointMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addComputePayloadSHA256(stack); err != nil {
+ return err
+ }
+ if err = addRecordResponseTiming(stack, options); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addCredentialSource(stack, options); err != nil {
+ return err
+ }
+ if err = addIdempotencyToken_opModifyApplicationStatusCheckMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addOpModifyApplicationStatusCheckValidationMiddleware(stack); err != nil {
+ return err
+ }
+ if err = stack.Initialize.Add(newServiceMetadataMiddleware(options.Region, "ModifyApplicationStatusCheck"), middleware.Before); err != nil {
+ return err
+ }
+ if err = addRequestIDRetrieverMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addResponseErrorMiddleware(stack); err != nil {
+ return err
+ }
+ if err = addRequestResponseLogging(stack, options); err != nil {
+ return err
+ }
+ if err = addDisableHTTPSMiddleware(stack, options); err != nil {
+ return err
+ }
+ if err = addInterceptors(stack, options); err != nil {
+ return err
+ }
+ return nil
+}
+
+type idempotencyToken_initializeOpModifyApplicationStatusCheck struct {
+ tokenProvider IdempotencyTokenProvider
+}
+
+func (*idempotencyToken_initializeOpModifyApplicationStatusCheck) ID() string {
+ return "OperationIdempotencyTokenAutoFill"
+}
+
+func (m *idempotencyToken_initializeOpModifyApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ if m.tokenProvider == nil {
+ return next.HandleInitialize(ctx, in)
+ }
+
+ input, ok := in.Parameters.(*ModifyApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("expected middleware input to be of type *ModifyApplicationStatusCheckInput ")
+ }
+
+ if input.ClientToken == nil {
+ t, err := m.tokenProvider.GetIdempotencyToken()
+ if err != nil {
+ return out, metadata, err
+ }
+ input.ClientToken = &t
+ }
+ return next.HandleInitialize(ctx, in)
+}
+func addIdempotencyToken_opModifyApplicationStatusCheckMiddleware(stack *middleware.Stack, cfg Options) error {
+ return stack.Initialize.Add(&idempotencyToken_initializeOpModifyApplicationStatusCheck{tokenProvider: cfg.IdempotencyTokenProvider}, middleware.Before)
+}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ProvisionByoipCidr.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ProvisionByoipCidr.go
index 47d636cd9..c9ac08772 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ProvisionByoipCidr.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/api_op_ProvisionByoipCidr.go
@@ -17,8 +17,10 @@ import (
// Amazon Web Services verifies that you own the address range and are authorized
// to advertise it. You must ensure that the address range is registered to you and
// that you created an RPKI ROA to authorize Amazon ASNs 16509 and 14618 to
-// advertise the address range. For more information, see [Bring your own IP addresses (BYOIP)]in the Amazon EC2 User
-// Guide.
+// advertise the address range. For the Amazon Web Services GovCloud (US) Regions,
+// authorize only ASN 8987. For the Amazon Web Services European Sovereign Cloud,
+// authorize ASNs 16509 and 214101. For more information, see [Bring your own IP addresses (BYOIP)]in the Amazon EC2
+// User Guide.
//
// Provisioning an address range is an asynchronous operation, so the call returns
// immediately, but the address range is not ready to use until its status changes
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go
index a7cd3a2de..f0b25fa65 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/deserializers.go
@@ -1734,14 +1734,14 @@ func awsEc2query_deserializeOpErrorAssociateAddress(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner struct {
+type awsEc2query_deserializeOpAssociateApplicationStatusCheck struct {
}
-func (*awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) ID() string {
+func (*awsEc2query_deserializeOpAssociateApplicationStatusCheck) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateApplicationStatusCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -1759,9 +1759,9 @@ func (m *awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) Hand
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateCapacityReservationBillingOwner(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateApplicationStatusCheck(response, &metadata)
}
- output := &AssociateCapacityReservationBillingOwnerOutput{}
+ output := &AssociateApplicationStatusCheckOutput{}
out.Result = output
var buff [1024]byte
@@ -1782,7 +1782,7 @@ func (m *awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) Hand
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateCapacityReservationBillingOwnerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateApplicationStatusCheckOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -1796,7 +1796,7 @@ func (m *awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) Hand
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateCapacityReservationBillingOwner(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateApplicationStatusCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -1829,14 +1829,14 @@ func awsEc2query_deserializeOpErrorAssociateCapacityReservationBillingOwner(resp
}
}
-type awsEc2query_deserializeOpAssociateClientVpnTargetNetwork struct {
+type awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner struct {
}
-func (*awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) ID() string {
+func (*awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateCapacityReservationBillingOwner) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -1854,9 +1854,9 @@ func (m *awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateClientVpnTargetNetwork(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateCapacityReservationBillingOwner(response, &metadata)
}
- output := &AssociateClientVpnTargetNetworkOutput{}
+ output := &AssociateCapacityReservationBillingOwnerOutput{}
out.Result = output
var buff [1024]byte
@@ -1877,7 +1877,7 @@ func (m *awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateClientVpnTargetNetworkOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateCapacityReservationBillingOwnerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -1891,79 +1891,7 @@ func (m *awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateClientVpnTargetNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error {
- var errorBuffer bytes.Buffer
- if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
- return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
- }
- errorBody := bytes.NewReader(errorBuffer.Bytes())
-
- errorCode := "UnknownError"
- errorMessage := errorCode
-
- errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
- if err != nil {
- return err
- }
- awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
- if len(errorComponents.Code) != 0 {
- errorCode = errorComponents.Code
- }
- if len(errorComponents.Message) != 0 {
- errorMessage = errorComponents.Message
- }
- errorBody.Seek(0, io.SeekStart)
- switch {
- default:
- genericError := &smithy.GenericAPIError{
- Code: errorCode,
- Message: errorMessage,
- }
- return genericError
-
- }
-}
-
-type awsEc2query_deserializeOpAssociateDhcpOptions struct {
-}
-
-func (*awsEc2query_deserializeOpAssociateDhcpOptions) ID() string {
- return "OperationDeserializer"
-}
-
-func (m *awsEc2query_deserializeOpAssociateDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
- out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
-) {
- out, metadata, err = next.HandleDeserialize(ctx, in)
- if err != nil {
- return out, metadata, err
- }
-
- _, span := tracing.StartSpan(ctx, "OperationDeserializer")
- endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
- defer endTimer()
- defer span.End()
- response, ok := out.RawResponse.(*smithyhttp.Response)
- if !ok {
- return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
- }
-
- if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateDhcpOptions(response, &metadata)
- }
- output := &AssociateDhcpOptionsOutput{}
- out.Result = output
-
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
- }
- }
-
- return out, metadata, err
-}
-
-func awsEc2query_deserializeOpErrorAssociateDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateCapacityReservationBillingOwner(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -1996,14 +1924,14 @@ func awsEc2query_deserializeOpErrorAssociateDhcpOptions(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole struct {
+type awsEc2query_deserializeOpAssociateClientVpnTargetNetwork struct {
}
-func (*awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) ID() string {
+func (*awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateClientVpnTargetNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2021,9 +1949,9 @@ func (m *awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateEnclaveCertificateIamRole(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateClientVpnTargetNetwork(response, &metadata)
}
- output := &AssociateEnclaveCertificateIamRoleOutput{}
+ output := &AssociateClientVpnTargetNetworkOutput{}
out.Result = output
var buff [1024]byte
@@ -2044,7 +1972,7 @@ func (m *awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateEnclaveCertificateIamRoleOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateClientVpnTargetNetworkOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2058,7 +1986,7 @@ func (m *awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateEnclaveCertificateIamRole(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateClientVpnTargetNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2091,14 +2019,14 @@ func awsEc2query_deserializeOpErrorAssociateEnclaveCertificateIamRole(response *
}
}
-type awsEc2query_deserializeOpAssociateIamInstanceProfile struct {
+type awsEc2query_deserializeOpAssociateDhcpOptions struct {
}
-func (*awsEc2query_deserializeOpAssociateIamInstanceProfile) ID() string {
+func (*awsEc2query_deserializeOpAssociateDhcpOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateIamInstanceProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2116,44 +2044,21 @@ func (m *awsEc2query_deserializeOpAssociateIamInstanceProfile) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateIamInstanceProfile(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateDhcpOptions(response, &metadata)
}
- output := &AssociateIamInstanceProfileOutput{}
+ output := &AssociateDhcpOptionsOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateIamInstanceProfileOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateIamInstanceProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2186,14 +2091,14 @@ func awsEc2query_deserializeOpErrorAssociateIamInstanceProfile(response *smithyh
}
}
-type awsEc2query_deserializeOpAssociateInstanceEventWindow struct {
+type awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole struct {
}
-func (*awsEc2query_deserializeOpAssociateInstanceEventWindow) ID() string {
+func (*awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateEnclaveCertificateIamRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2211,9 +2116,9 @@ func (m *awsEc2query_deserializeOpAssociateInstanceEventWindow) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateInstanceEventWindow(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateEnclaveCertificateIamRole(response, &metadata)
}
- output := &AssociateInstanceEventWindowOutput{}
+ output := &AssociateEnclaveCertificateIamRoleOutput{}
out.Result = output
var buff [1024]byte
@@ -2234,7 +2139,7 @@ func (m *awsEc2query_deserializeOpAssociateInstanceEventWindow) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateInstanceEventWindowOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateEnclaveCertificateIamRoleOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2248,7 +2153,7 @@ func (m *awsEc2query_deserializeOpAssociateInstanceEventWindow) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateEnclaveCertificateIamRole(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2281,14 +2186,14 @@ func awsEc2query_deserializeOpErrorAssociateInstanceEventWindow(response *smithy
}
}
-type awsEc2query_deserializeOpAssociateIpamByoasn struct {
+type awsEc2query_deserializeOpAssociateIamInstanceProfile struct {
}
-func (*awsEc2query_deserializeOpAssociateIpamByoasn) ID() string {
+func (*awsEc2query_deserializeOpAssociateIamInstanceProfile) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateIamInstanceProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2306,9 +2211,9 @@ func (m *awsEc2query_deserializeOpAssociateIpamByoasn) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateIpamByoasn(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateIamInstanceProfile(response, &metadata)
}
- output := &AssociateIpamByoasnOutput{}
+ output := &AssociateIamInstanceProfileOutput{}
out.Result = output
var buff [1024]byte
@@ -2329,7 +2234,7 @@ func (m *awsEc2query_deserializeOpAssociateIpamByoasn) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateIpamByoasnOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateIamInstanceProfileOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2343,7 +2248,7 @@ func (m *awsEc2query_deserializeOpAssociateIpamByoasn) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateIamInstanceProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2376,14 +2281,14 @@ func awsEc2query_deserializeOpErrorAssociateIpamByoasn(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpAssociateIpamResourceDiscovery struct {
+type awsEc2query_deserializeOpAssociateInstanceEventWindow struct {
}
-func (*awsEc2query_deserializeOpAssociateIpamResourceDiscovery) ID() string {
+func (*awsEc2query_deserializeOpAssociateInstanceEventWindow) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2401,9 +2306,9 @@ func (m *awsEc2query_deserializeOpAssociateIpamResourceDiscovery) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateInstanceEventWindow(response, &metadata)
}
- output := &AssociateIpamResourceDiscoveryOutput{}
+ output := &AssociateInstanceEventWindowOutput{}
out.Result = output
var buff [1024]byte
@@ -2424,7 +2329,7 @@ func (m *awsEc2query_deserializeOpAssociateIpamResourceDiscovery) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateIpamResourceDiscoveryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateInstanceEventWindowOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2438,7 +2343,7 @@ func (m *awsEc2query_deserializeOpAssociateIpamResourceDiscovery) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2471,14 +2376,14 @@ func awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response *smit
}
}
-type awsEc2query_deserializeOpAssociateNatGatewayAddress struct {
+type awsEc2query_deserializeOpAssociateIpamByoasn struct {
}
-func (*awsEc2query_deserializeOpAssociateNatGatewayAddress) ID() string {
+func (*awsEc2query_deserializeOpAssociateIpamByoasn) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateNatGatewayAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2496,9 +2401,9 @@ func (m *awsEc2query_deserializeOpAssociateNatGatewayAddress) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateNatGatewayAddress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateIpamByoasn(response, &metadata)
}
- output := &AssociateNatGatewayAddressOutput{}
+ output := &AssociateIpamByoasnOutput{}
out.Result = output
var buff [1024]byte
@@ -2519,7 +2424,7 @@ func (m *awsEc2query_deserializeOpAssociateNatGatewayAddress) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateNatGatewayAddressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateIpamByoasnOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2533,7 +2438,7 @@ func (m *awsEc2query_deserializeOpAssociateNatGatewayAddress) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateNatGatewayAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2566,14 +2471,14 @@ func awsEc2query_deserializeOpErrorAssociateNatGatewayAddress(response *smithyht
}
}
-type awsEc2query_deserializeOpAssociateRouteServer struct {
+type awsEc2query_deserializeOpAssociateIpamResourceDiscovery struct {
}
-func (*awsEc2query_deserializeOpAssociateRouteServer) ID() string {
+func (*awsEc2query_deserializeOpAssociateIpamResourceDiscovery) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2591,9 +2496,9 @@ func (m *awsEc2query_deserializeOpAssociateRouteServer) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateRouteServer(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response, &metadata)
}
- output := &AssociateRouteServerOutput{}
+ output := &AssociateIpamResourceDiscoveryOutput{}
out.Result = output
var buff [1024]byte
@@ -2614,7 +2519,7 @@ func (m *awsEc2query_deserializeOpAssociateRouteServer) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateRouteServerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateIpamResourceDiscoveryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2628,7 +2533,7 @@ func (m *awsEc2query_deserializeOpAssociateRouteServer) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2661,14 +2566,14 @@ func awsEc2query_deserializeOpErrorAssociateRouteServer(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpAssociateRouteTable struct {
+type awsEc2query_deserializeOpAssociateNatGatewayAddress struct {
}
-func (*awsEc2query_deserializeOpAssociateRouteTable) ID() string {
+func (*awsEc2query_deserializeOpAssociateNatGatewayAddress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateNatGatewayAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2686,9 +2591,9 @@ func (m *awsEc2query_deserializeOpAssociateRouteTable) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateRouteTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateNatGatewayAddress(response, &metadata)
}
- output := &AssociateRouteTableOutput{}
+ output := &AssociateNatGatewayAddressOutput{}
out.Result = output
var buff [1024]byte
@@ -2709,7 +2614,7 @@ func (m *awsEc2query_deserializeOpAssociateRouteTable) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateRouteTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateNatGatewayAddressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2723,7 +2628,7 @@ func (m *awsEc2query_deserializeOpAssociateRouteTable) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateNatGatewayAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2756,14 +2661,14 @@ func awsEc2query_deserializeOpErrorAssociateRouteTable(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpAssociateSecurityGroupVpc struct {
+type awsEc2query_deserializeOpAssociateRouteServer struct {
}
-func (*awsEc2query_deserializeOpAssociateSecurityGroupVpc) ID() string {
+func (*awsEc2query_deserializeOpAssociateRouteServer) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateSecurityGroupVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2781,9 +2686,9 @@ func (m *awsEc2query_deserializeOpAssociateSecurityGroupVpc) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateSecurityGroupVpc(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateRouteServer(response, &metadata)
}
- output := &AssociateSecurityGroupVpcOutput{}
+ output := &AssociateRouteServerOutput{}
out.Result = output
var buff [1024]byte
@@ -2804,7 +2709,7 @@ func (m *awsEc2query_deserializeOpAssociateSecurityGroupVpc) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateSecurityGroupVpcOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateRouteServerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2818,7 +2723,7 @@ func (m *awsEc2query_deserializeOpAssociateSecurityGroupVpc) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateSecurityGroupVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2851,14 +2756,14 @@ func awsEc2query_deserializeOpErrorAssociateSecurityGroupVpc(response *smithyhtt
}
}
-type awsEc2query_deserializeOpAssociateSubnetCidrBlock struct {
+type awsEc2query_deserializeOpAssociateRouteTable struct {
}
-func (*awsEc2query_deserializeOpAssociateSubnetCidrBlock) ID() string {
+func (*awsEc2query_deserializeOpAssociateRouteTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateSubnetCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2876,9 +2781,9 @@ func (m *awsEc2query_deserializeOpAssociateSubnetCidrBlock) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateSubnetCidrBlock(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateRouteTable(response, &metadata)
}
- output := &AssociateSubnetCidrBlockOutput{}
+ output := &AssociateRouteTableOutput{}
out.Result = output
var buff [1024]byte
@@ -2899,7 +2804,7 @@ func (m *awsEc2query_deserializeOpAssociateSubnetCidrBlock) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateSubnetCidrBlockOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateRouteTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -2913,7 +2818,7 @@ func (m *awsEc2query_deserializeOpAssociateSubnetCidrBlock) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateSubnetCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -2946,14 +2851,14 @@ func awsEc2query_deserializeOpErrorAssociateSubnetCidrBlock(response *smithyhttp
}
}
-type awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain struct {
+type awsEc2query_deserializeOpAssociateSecurityGroupVpc struct {
}
-func (*awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) ID() string {
+func (*awsEc2query_deserializeOpAssociateSecurityGroupVpc) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateSecurityGroupVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -2971,9 +2876,9 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) Handle
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateTransitGatewayMulticastDomain(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateSecurityGroupVpc(response, &metadata)
}
- output := &AssociateTransitGatewayMulticastDomainOutput{}
+ output := &AssociateSecurityGroupVpcOutput{}
out.Result = output
var buff [1024]byte
@@ -2994,7 +2899,7 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) Handle
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateTransitGatewayMulticastDomainOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateSecurityGroupVpcOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3008,7 +2913,7 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) Handle
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateSecurityGroupVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3041,14 +2946,14 @@ func awsEc2query_deserializeOpErrorAssociateTransitGatewayMulticastDomain(respon
}
}
-type awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable struct {
+type awsEc2query_deserializeOpAssociateSubnetCidrBlock struct {
}
-func (*awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) ID() string {
+func (*awsEc2query_deserializeOpAssociateSubnetCidrBlock) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateSubnetCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3066,9 +2971,9 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateTransitGatewayPolicyTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateSubnetCidrBlock(response, &metadata)
}
- output := &AssociateTransitGatewayPolicyTableOutput{}
+ output := &AssociateSubnetCidrBlockOutput{}
out.Result = output
var buff [1024]byte
@@ -3089,7 +2994,7 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateTransitGatewayPolicyTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateSubnetCidrBlockOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3103,7 +3008,7 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateSubnetCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3136,14 +3041,14 @@ func awsEc2query_deserializeOpErrorAssociateTransitGatewayPolicyTable(response *
}
}
-type awsEc2query_deserializeOpAssociateTransitGatewayRouteTable struct {
+type awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain struct {
}
-func (*awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) ID() string {
+func (*awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3161,9 +3066,9 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateTransitGatewayRouteTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateTransitGatewayMulticastDomain(response, &metadata)
}
- output := &AssociateTransitGatewayRouteTableOutput{}
+ output := &AssociateTransitGatewayMulticastDomainOutput{}
out.Result = output
var buff [1024]byte
@@ -3184,7 +3089,7 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateTransitGatewayRouteTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateTransitGatewayMulticastDomainOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3198,7 +3103,7 @@ func (m *awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3231,14 +3136,14 @@ func awsEc2query_deserializeOpErrorAssociateTransitGatewayRouteTable(response *s
}
}
-type awsEc2query_deserializeOpAssociateTrunkInterface struct {
+type awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable struct {
}
-func (*awsEc2query_deserializeOpAssociateTrunkInterface) ID() string {
+func (*awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateTrunkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3256,9 +3161,9 @@ func (m *awsEc2query_deserializeOpAssociateTrunkInterface) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateTrunkInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateTransitGatewayPolicyTable(response, &metadata)
}
- output := &AssociateTrunkInterfaceOutput{}
+ output := &AssociateTransitGatewayPolicyTableOutput{}
out.Result = output
var buff [1024]byte
@@ -3279,7 +3184,7 @@ func (m *awsEc2query_deserializeOpAssociateTrunkInterface) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateTrunkInterfaceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateTransitGatewayPolicyTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3293,7 +3198,7 @@ func (m *awsEc2query_deserializeOpAssociateTrunkInterface) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateTrunkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3326,14 +3231,14 @@ func awsEc2query_deserializeOpErrorAssociateTrunkInterface(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpAssociateVpcCidrBlock struct {
+type awsEc2query_deserializeOpAssociateTransitGatewayRouteTable struct {
}
-func (*awsEc2query_deserializeOpAssociateVpcCidrBlock) ID() string {
+func (*awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAssociateVpcCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3351,9 +3256,9 @@ func (m *awsEc2query_deserializeOpAssociateVpcCidrBlock) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAssociateVpcCidrBlock(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateTransitGatewayRouteTable(response, &metadata)
}
- output := &AssociateVpcCidrBlockOutput{}
+ output := &AssociateTransitGatewayRouteTableOutput{}
out.Result = output
var buff [1024]byte
@@ -3374,7 +3279,7 @@ func (m *awsEc2query_deserializeOpAssociateVpcCidrBlock) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAssociateVpcCidrBlockOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateTransitGatewayRouteTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3388,7 +3293,7 @@ func (m *awsEc2query_deserializeOpAssociateVpcCidrBlock) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAssociateVpcCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3421,14 +3326,14 @@ func awsEc2query_deserializeOpErrorAssociateVpcCidrBlock(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpAttachClassicLinkVpc struct {
+type awsEc2query_deserializeOpAssociateTrunkInterface struct {
}
-func (*awsEc2query_deserializeOpAttachClassicLinkVpc) ID() string {
+func (*awsEc2query_deserializeOpAssociateTrunkInterface) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachClassicLinkVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateTrunkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3446,9 +3351,9 @@ func (m *awsEc2query_deserializeOpAttachClassicLinkVpc) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachClassicLinkVpc(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateTrunkInterface(response, &metadata)
}
- output := &AttachClassicLinkVpcOutput{}
+ output := &AssociateTrunkInterfaceOutput{}
out.Result = output
var buff [1024]byte
@@ -3469,7 +3374,7 @@ func (m *awsEc2query_deserializeOpAttachClassicLinkVpc) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAttachClassicLinkVpcOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateTrunkInterfaceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3483,7 +3388,7 @@ func (m *awsEc2query_deserializeOpAttachClassicLinkVpc) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachClassicLinkVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateTrunkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3516,14 +3421,14 @@ func awsEc2query_deserializeOpErrorAttachClassicLinkVpc(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpAttachImageWatermark struct {
+type awsEc2query_deserializeOpAssociateVpcCidrBlock struct {
}
-func (*awsEc2query_deserializeOpAttachImageWatermark) ID() string {
+func (*awsEc2query_deserializeOpAssociateVpcCidrBlock) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachImageWatermark) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAssociateVpcCidrBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3541,9 +3446,9 @@ func (m *awsEc2query_deserializeOpAttachImageWatermark) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachImageWatermark(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAssociateVpcCidrBlock(response, &metadata)
}
- output := &AttachImageWatermarkOutput{}
+ output := &AssociateVpcCidrBlockOutput{}
out.Result = output
var buff [1024]byte
@@ -3564,7 +3469,7 @@ func (m *awsEc2query_deserializeOpAttachImageWatermark) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAttachImageWatermarkOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAssociateVpcCidrBlockOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3578,7 +3483,7 @@ func (m *awsEc2query_deserializeOpAttachImageWatermark) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachImageWatermark(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAssociateVpcCidrBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3611,14 +3516,14 @@ func awsEc2query_deserializeOpErrorAttachImageWatermark(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpAttachInternetGateway struct {
+type awsEc2query_deserializeOpAttachClassicLinkVpc struct {
}
-func (*awsEc2query_deserializeOpAttachInternetGateway) ID() string {
+func (*awsEc2query_deserializeOpAttachClassicLinkVpc) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachClassicLinkVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3636,21 +3541,44 @@ func (m *awsEc2query_deserializeOpAttachInternetGateway) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachInternetGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachClassicLinkVpc(response, &metadata)
}
- output := &AttachInternetGatewayOutput{}
+ output := &AttachClassicLinkVpcOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentAttachClassicLinkVpcOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachClassicLinkVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3683,14 +3611,14 @@ func awsEc2query_deserializeOpErrorAttachInternetGateway(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpAttachNetworkInterface struct {
+type awsEc2query_deserializeOpAttachImageWatermark struct {
}
-func (*awsEc2query_deserializeOpAttachNetworkInterface) ID() string {
+func (*awsEc2query_deserializeOpAttachImageWatermark) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachImageWatermark) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3708,9 +3636,9 @@ func (m *awsEc2query_deserializeOpAttachNetworkInterface) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachNetworkInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachImageWatermark(response, &metadata)
}
- output := &AttachNetworkInterfaceOutput{}
+ output := &AttachImageWatermarkOutput{}
out.Result = output
var buff [1024]byte
@@ -3731,7 +3659,7 @@ func (m *awsEc2query_deserializeOpAttachNetworkInterface) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAttachNetworkInterfaceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAttachImageWatermarkOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3745,7 +3673,7 @@ func (m *awsEc2query_deserializeOpAttachNetworkInterface) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachImageWatermark(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3778,14 +3706,14 @@ func awsEc2query_deserializeOpErrorAttachNetworkInterface(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider struct {
+type awsEc2query_deserializeOpAttachInternetGateway struct {
}
-func (*awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider) ID() string {
+func (*awsEc2query_deserializeOpAttachInternetGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3803,44 +3731,21 @@ func (m *awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachVerifiedAccessTrustProvider(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachInternetGateway(response, &metadata)
}
- output := &AttachVerifiedAccessTrustProviderOutput{}
+ output := &AttachInternetGatewayOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAttachVerifiedAccessTrustProviderOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3873,14 +3778,14 @@ func awsEc2query_deserializeOpErrorAttachVerifiedAccessTrustProvider(response *s
}
}
-type awsEc2query_deserializeOpAttachVolume struct {
+type awsEc2query_deserializeOpAttachNetworkInterface struct {
}
-func (*awsEc2query_deserializeOpAttachVolume) ID() string {
+func (*awsEc2query_deserializeOpAttachNetworkInterface) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3898,9 +3803,9 @@ func (m *awsEc2query_deserializeOpAttachVolume) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachVolume(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachNetworkInterface(response, &metadata)
}
- output := &AttachVolumeOutput{}
+ output := &AttachNetworkInterfaceOutput{}
out.Result = output
var buff [1024]byte
@@ -3921,7 +3826,7 @@ func (m *awsEc2query_deserializeOpAttachVolume) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAttachVolumeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAttachNetworkInterfaceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -3935,7 +3840,7 @@ func (m *awsEc2query_deserializeOpAttachVolume) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -3968,14 +3873,14 @@ func awsEc2query_deserializeOpErrorAttachVolume(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpAttachVpnGateway struct {
+type awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider struct {
}
-func (*awsEc2query_deserializeOpAttachVpnGateway) ID() string {
+func (*awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAttachVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -3993,9 +3898,9 @@ func (m *awsEc2query_deserializeOpAttachVpnGateway) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAttachVpnGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachVerifiedAccessTrustProvider(response, &metadata)
}
- output := &AttachVpnGatewayOutput{}
+ output := &AttachVerifiedAccessTrustProviderOutput{}
out.Result = output
var buff [1024]byte
@@ -4016,7 +3921,7 @@ func (m *awsEc2query_deserializeOpAttachVpnGateway) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAttachVpnGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAttachVerifiedAccessTrustProviderOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4030,7 +3935,7 @@ func (m *awsEc2query_deserializeOpAttachVpnGateway) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAttachVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4063,14 +3968,14 @@ func awsEc2query_deserializeOpErrorAttachVpnGateway(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpAuthorizeClientVpnIngress struct {
+type awsEc2query_deserializeOpAttachVolume struct {
}
-func (*awsEc2query_deserializeOpAuthorizeClientVpnIngress) ID() string {
+func (*awsEc2query_deserializeOpAttachVolume) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAuthorizeClientVpnIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4088,9 +3993,9 @@ func (m *awsEc2query_deserializeOpAuthorizeClientVpnIngress) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAuthorizeClientVpnIngress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachVolume(response, &metadata)
}
- output := &AuthorizeClientVpnIngressOutput{}
+ output := &AttachVolumeOutput{}
out.Result = output
var buff [1024]byte
@@ -4111,7 +4016,7 @@ func (m *awsEc2query_deserializeOpAuthorizeClientVpnIngress) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAuthorizeClientVpnIngressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAttachVolumeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4125,7 +4030,7 @@ func (m *awsEc2query_deserializeOpAuthorizeClientVpnIngress) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAuthorizeClientVpnIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4158,14 +4063,14 @@ func awsEc2query_deserializeOpErrorAuthorizeClientVpnIngress(response *smithyhtt
}
}
-type awsEc2query_deserializeOpAuthorizeSecurityGroupEgress struct {
+type awsEc2query_deserializeOpAttachVpnGateway struct {
}
-func (*awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) ID() string {
+func (*awsEc2query_deserializeOpAttachVpnGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAttachVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4183,9 +4088,9 @@ func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAuthorizeSecurityGroupEgress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAttachVpnGateway(response, &metadata)
}
- output := &AuthorizeSecurityGroupEgressOutput{}
+ output := &AttachVpnGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -4206,7 +4111,7 @@ func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAuthorizeSecurityGroupEgressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAttachVpnGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4220,7 +4125,7 @@ func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAuthorizeSecurityGroupEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAttachVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4253,14 +4158,14 @@ func awsEc2query_deserializeOpErrorAuthorizeSecurityGroupEgress(response *smithy
}
}
-type awsEc2query_deserializeOpAuthorizeSecurityGroupIngress struct {
+type awsEc2query_deserializeOpAuthorizeClientVpnIngress struct {
}
-func (*awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) ID() string {
+func (*awsEc2query_deserializeOpAuthorizeClientVpnIngress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAuthorizeClientVpnIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4278,9 +4183,9 @@ func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorAuthorizeSecurityGroupIngress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAuthorizeClientVpnIngress(response, &metadata)
}
- output := &AuthorizeSecurityGroupIngressOutput{}
+ output := &AuthorizeClientVpnIngressOutput{}
out.Result = output
var buff [1024]byte
@@ -4301,7 +4206,7 @@ func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentAuthorizeSecurityGroupIngressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAuthorizeClientVpnIngressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4315,7 +4220,7 @@ func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorAuthorizeSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAuthorizeClientVpnIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4348,14 +4253,14 @@ func awsEc2query_deserializeOpErrorAuthorizeSecurityGroupIngress(response *smith
}
}
-type awsEc2query_deserializeOpBundleInstance struct {
+type awsEc2query_deserializeOpAuthorizeSecurityGroupEgress struct {
}
-func (*awsEc2query_deserializeOpBundleInstance) ID() string {
+func (*awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpBundleInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4373,9 +4278,9 @@ func (m *awsEc2query_deserializeOpBundleInstance) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorBundleInstance(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAuthorizeSecurityGroupEgress(response, &metadata)
}
- output := &BundleInstanceOutput{}
+ output := &AuthorizeSecurityGroupEgressOutput{}
out.Result = output
var buff [1024]byte
@@ -4396,7 +4301,7 @@ func (m *awsEc2query_deserializeOpBundleInstance) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentBundleInstanceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAuthorizeSecurityGroupEgressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4410,7 +4315,7 @@ func (m *awsEc2query_deserializeOpBundleInstance) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorBundleInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAuthorizeSecurityGroupEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4443,14 +4348,14 @@ func awsEc2query_deserializeOpErrorBundleInstance(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCancelBundleTask struct {
+type awsEc2query_deserializeOpAuthorizeSecurityGroupIngress struct {
}
-func (*awsEc2query_deserializeOpCancelBundleTask) ID() string {
+func (*awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelBundleTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpAuthorizeSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4468,9 +4373,9 @@ func (m *awsEc2query_deserializeOpCancelBundleTask) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelBundleTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorAuthorizeSecurityGroupIngress(response, &metadata)
}
- output := &CancelBundleTaskOutput{}
+ output := &AuthorizeSecurityGroupIngressOutput{}
out.Result = output
var buff [1024]byte
@@ -4491,7 +4396,7 @@ func (m *awsEc2query_deserializeOpCancelBundleTask) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelBundleTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentAuthorizeSecurityGroupIngressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4505,7 +4410,7 @@ func (m *awsEc2query_deserializeOpCancelBundleTask) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelBundleTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorAuthorizeSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4538,14 +4443,14 @@ func awsEc2query_deserializeOpErrorCancelBundleTask(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCancelCapacityReservation struct {
+type awsEc2query_deserializeOpBundleInstance struct {
}
-func (*awsEc2query_deserializeOpCancelCapacityReservation) ID() string {
+func (*awsEc2query_deserializeOpBundleInstance) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpBundleInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4563,9 +4468,9 @@ func (m *awsEc2query_deserializeOpCancelCapacityReservation) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelCapacityReservation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorBundleInstance(response, &metadata)
}
- output := &CancelCapacityReservationOutput{}
+ output := &BundleInstanceOutput{}
out.Result = output
var buff [1024]byte
@@ -4586,7 +4491,7 @@ func (m *awsEc2query_deserializeOpCancelCapacityReservation) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelCapacityReservationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentBundleInstanceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4600,7 +4505,7 @@ func (m *awsEc2query_deserializeOpCancelCapacityReservation) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorBundleInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4633,14 +4538,14 @@ func awsEc2query_deserializeOpErrorCancelCapacityReservation(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCancelCapacityReservationFleets struct {
+type awsEc2query_deserializeOpCancelBundleTask struct {
}
-func (*awsEc2query_deserializeOpCancelCapacityReservationFleets) ID() string {
+func (*awsEc2query_deserializeOpCancelBundleTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelCapacityReservationFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelBundleTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4658,9 +4563,9 @@ func (m *awsEc2query_deserializeOpCancelCapacityReservationFleets) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelCapacityReservationFleets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelBundleTask(response, &metadata)
}
- output := &CancelCapacityReservationFleetsOutput{}
+ output := &CancelBundleTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -4681,7 +4586,7 @@ func (m *awsEc2query_deserializeOpCancelCapacityReservationFleets) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelCapacityReservationFleetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelBundleTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4695,7 +4600,7 @@ func (m *awsEc2query_deserializeOpCancelCapacityReservationFleets) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelCapacityReservationFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelBundleTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4728,14 +4633,14 @@ func awsEc2query_deserializeOpErrorCancelCapacityReservationFleets(response *smi
}
}
-type awsEc2query_deserializeOpCancelConversionTask struct {
+type awsEc2query_deserializeOpCancelCapacityReservation struct {
}
-func (*awsEc2query_deserializeOpCancelConversionTask) ID() string {
+func (*awsEc2query_deserializeOpCancelCapacityReservation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelConversionTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4753,21 +4658,44 @@ func (m *awsEc2query_deserializeOpCancelConversionTask) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelConversionTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelCapacityReservation(response, &metadata)
}
- output := &CancelConversionTaskOutput{}
+ output := &CancelCapacityReservationOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentCancelCapacityReservationOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelConversionTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4800,14 +4728,14 @@ func awsEc2query_deserializeOpErrorCancelConversionTask(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCancelDeclarativePoliciesReport struct {
+type awsEc2query_deserializeOpCancelCapacityReservationFleets struct {
}
-func (*awsEc2query_deserializeOpCancelDeclarativePoliciesReport) ID() string {
+func (*awsEc2query_deserializeOpCancelCapacityReservationFleets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelDeclarativePoliciesReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelCapacityReservationFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4825,9 +4753,9 @@ func (m *awsEc2query_deserializeOpCancelDeclarativePoliciesReport) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelDeclarativePoliciesReport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelCapacityReservationFleets(response, &metadata)
}
- output := &CancelDeclarativePoliciesReportOutput{}
+ output := &CancelCapacityReservationFleetsOutput{}
out.Result = output
var buff [1024]byte
@@ -4848,7 +4776,7 @@ func (m *awsEc2query_deserializeOpCancelDeclarativePoliciesReport) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelDeclarativePoliciesReportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelCapacityReservationFleetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -4862,7 +4790,7 @@ func (m *awsEc2query_deserializeOpCancelDeclarativePoliciesReport) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelDeclarativePoliciesReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelCapacityReservationFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4895,14 +4823,14 @@ func awsEc2query_deserializeOpErrorCancelDeclarativePoliciesReport(response *smi
}
}
-type awsEc2query_deserializeOpCancelExportTask struct {
+type awsEc2query_deserializeOpCancelConversionTask struct {
}
-func (*awsEc2query_deserializeOpCancelExportTask) ID() string {
+func (*awsEc2query_deserializeOpCancelConversionTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelConversionTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4920,9 +4848,9 @@ func (m *awsEc2query_deserializeOpCancelExportTask) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelExportTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelConversionTask(response, &metadata)
}
- output := &CancelExportTaskOutput{}
+ output := &CancelConversionTaskOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -4934,7 +4862,7 @@ func (m *awsEc2query_deserializeOpCancelExportTask) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelConversionTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -4967,14 +4895,14 @@ func awsEc2query_deserializeOpErrorCancelExportTask(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCancelImageLaunchPermission struct {
+type awsEc2query_deserializeOpCancelDeclarativePoliciesReport struct {
}
-func (*awsEc2query_deserializeOpCancelImageLaunchPermission) ID() string {
+func (*awsEc2query_deserializeOpCancelDeclarativePoliciesReport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelImageLaunchPermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelDeclarativePoliciesReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -4992,9 +4920,9 @@ func (m *awsEc2query_deserializeOpCancelImageLaunchPermission) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelImageLaunchPermission(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelDeclarativePoliciesReport(response, &metadata)
}
- output := &CancelImageLaunchPermissionOutput{}
+ output := &CancelDeclarativePoliciesReportOutput{}
out.Result = output
var buff [1024]byte
@@ -5015,7 +4943,7 @@ func (m *awsEc2query_deserializeOpCancelImageLaunchPermission) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelImageLaunchPermissionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelDeclarativePoliciesReportOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5029,7 +4957,7 @@ func (m *awsEc2query_deserializeOpCancelImageLaunchPermission) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelImageLaunchPermission(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelDeclarativePoliciesReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5062,14 +4990,14 @@ func awsEc2query_deserializeOpErrorCancelImageLaunchPermission(response *smithyh
}
}
-type awsEc2query_deserializeOpCancelImportTask struct {
+type awsEc2query_deserializeOpCancelExportTask struct {
}
-func (*awsEc2query_deserializeOpCancelImportTask) ID() string {
+func (*awsEc2query_deserializeOpCancelExportTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelImportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5087,44 +5015,21 @@ func (m *awsEc2query_deserializeOpCancelImportTask) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelImportTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelExportTask(response, &metadata)
}
- output := &CancelImportTaskOutput{}
+ output := &CancelExportTaskOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelImportTaskOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelImportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5157,14 +5062,14 @@ func awsEc2query_deserializeOpErrorCancelImportTask(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCancelReservedInstancesListing struct {
+type awsEc2query_deserializeOpCancelImageLaunchPermission struct {
}
-func (*awsEc2query_deserializeOpCancelReservedInstancesListing) ID() string {
+func (*awsEc2query_deserializeOpCancelImageLaunchPermission) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelReservedInstancesListing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelImageLaunchPermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5182,9 +5087,9 @@ func (m *awsEc2query_deserializeOpCancelReservedInstancesListing) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelReservedInstancesListing(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelImageLaunchPermission(response, &metadata)
}
- output := &CancelReservedInstancesListingOutput{}
+ output := &CancelImageLaunchPermissionOutput{}
out.Result = output
var buff [1024]byte
@@ -5205,7 +5110,7 @@ func (m *awsEc2query_deserializeOpCancelReservedInstancesListing) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelReservedInstancesListingOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelImageLaunchPermissionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5219,7 +5124,7 @@ func (m *awsEc2query_deserializeOpCancelReservedInstancesListing) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelReservedInstancesListing(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelImageLaunchPermission(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5252,14 +5157,14 @@ func awsEc2query_deserializeOpErrorCancelReservedInstancesListing(response *smit
}
}
-type awsEc2query_deserializeOpCancelSpotFleetRequests struct {
+type awsEc2query_deserializeOpCancelImportTask struct {
}
-func (*awsEc2query_deserializeOpCancelSpotFleetRequests) ID() string {
+func (*awsEc2query_deserializeOpCancelImportTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelSpotFleetRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelImportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5277,9 +5182,9 @@ func (m *awsEc2query_deserializeOpCancelSpotFleetRequests) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelSpotFleetRequests(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelImportTask(response, &metadata)
}
- output := &CancelSpotFleetRequestsOutput{}
+ output := &CancelImportTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -5300,7 +5205,7 @@ func (m *awsEc2query_deserializeOpCancelSpotFleetRequests) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelSpotFleetRequestsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelImportTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5314,7 +5219,7 @@ func (m *awsEc2query_deserializeOpCancelSpotFleetRequests) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelSpotFleetRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelImportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5347,14 +5252,14 @@ func awsEc2query_deserializeOpErrorCancelSpotFleetRequests(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpCancelSpotInstanceRequests struct {
+type awsEc2query_deserializeOpCancelReservedInstancesListing struct {
}
-func (*awsEc2query_deserializeOpCancelSpotInstanceRequests) ID() string {
+func (*awsEc2query_deserializeOpCancelReservedInstancesListing) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCancelSpotInstanceRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelReservedInstancesListing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5372,9 +5277,9 @@ func (m *awsEc2query_deserializeOpCancelSpotInstanceRequests) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCancelSpotInstanceRequests(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelReservedInstancesListing(response, &metadata)
}
- output := &CancelSpotInstanceRequestsOutput{}
+ output := &CancelReservedInstancesListingOutput{}
out.Result = output
var buff [1024]byte
@@ -5395,7 +5300,7 @@ func (m *awsEc2query_deserializeOpCancelSpotInstanceRequests) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCancelSpotInstanceRequestsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelReservedInstancesListingOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5409,7 +5314,7 @@ func (m *awsEc2query_deserializeOpCancelSpotInstanceRequests) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCancelSpotInstanceRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelReservedInstancesListing(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5442,14 +5347,14 @@ func awsEc2query_deserializeOpErrorCancelSpotInstanceRequests(response *smithyht
}
}
-type awsEc2query_deserializeOpConfirmProductInstance struct {
+type awsEc2query_deserializeOpCancelSpotFleetRequests struct {
}
-func (*awsEc2query_deserializeOpConfirmProductInstance) ID() string {
+func (*awsEc2query_deserializeOpCancelSpotFleetRequests) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpConfirmProductInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelSpotFleetRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5467,9 +5372,9 @@ func (m *awsEc2query_deserializeOpConfirmProductInstance) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorConfirmProductInstance(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelSpotFleetRequests(response, &metadata)
}
- output := &ConfirmProductInstanceOutput{}
+ output := &CancelSpotFleetRequestsOutput{}
out.Result = output
var buff [1024]byte
@@ -5490,7 +5395,7 @@ func (m *awsEc2query_deserializeOpConfirmProductInstance) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentConfirmProductInstanceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelSpotFleetRequestsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5504,7 +5409,7 @@ func (m *awsEc2query_deserializeOpConfirmProductInstance) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorConfirmProductInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelSpotFleetRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5537,14 +5442,14 @@ func awsEc2query_deserializeOpErrorConfirmProductInstance(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpCopyFpgaImage struct {
+type awsEc2query_deserializeOpCancelSpotInstanceRequests struct {
}
-func (*awsEc2query_deserializeOpCopyFpgaImage) ID() string {
+func (*awsEc2query_deserializeOpCancelSpotInstanceRequests) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCopyFpgaImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCancelSpotInstanceRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5562,9 +5467,9 @@ func (m *awsEc2query_deserializeOpCopyFpgaImage) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCopyFpgaImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCancelSpotInstanceRequests(response, &metadata)
}
- output := &CopyFpgaImageOutput{}
+ output := &CancelSpotInstanceRequestsOutput{}
out.Result = output
var buff [1024]byte
@@ -5585,7 +5490,7 @@ func (m *awsEc2query_deserializeOpCopyFpgaImage) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCopyFpgaImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCancelSpotInstanceRequestsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5599,7 +5504,7 @@ func (m *awsEc2query_deserializeOpCopyFpgaImage) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCopyFpgaImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCancelSpotInstanceRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5632,14 +5537,14 @@ func awsEc2query_deserializeOpErrorCopyFpgaImage(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCopyImage struct {
+type awsEc2query_deserializeOpConfirmProductInstance struct {
}
-func (*awsEc2query_deserializeOpCopyImage) ID() string {
+func (*awsEc2query_deserializeOpConfirmProductInstance) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCopyImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpConfirmProductInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5657,9 +5562,9 @@ func (m *awsEc2query_deserializeOpCopyImage) HandleDeserialize(ctx context.Conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCopyImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorConfirmProductInstance(response, &metadata)
}
- output := &CopyImageOutput{}
+ output := &ConfirmProductInstanceOutput{}
out.Result = output
var buff [1024]byte
@@ -5680,7 +5585,7 @@ func (m *awsEc2query_deserializeOpCopyImage) HandleDeserialize(ctx context.Conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCopyImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentConfirmProductInstanceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5694,7 +5599,7 @@ func (m *awsEc2query_deserializeOpCopyImage) HandleDeserialize(ctx context.Conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCopyImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorConfirmProductInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5727,14 +5632,14 @@ func awsEc2query_deserializeOpErrorCopyImage(response *smithyhttp.Response, meta
}
}
-type awsEc2query_deserializeOpCopySnapshot struct {
+type awsEc2query_deserializeOpCopyFpgaImage struct {
}
-func (*awsEc2query_deserializeOpCopySnapshot) ID() string {
+func (*awsEc2query_deserializeOpCopyFpgaImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCopyFpgaImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5752,9 +5657,9 @@ func (m *awsEc2query_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCopySnapshot(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCopyFpgaImage(response, &metadata)
}
- output := &CopySnapshotOutput{}
+ output := &CopyFpgaImageOutput{}
out.Result = output
var buff [1024]byte
@@ -5775,7 +5680,7 @@ func (m *awsEc2query_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCopySnapshotOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCopyFpgaImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5789,7 +5694,7 @@ func (m *awsEc2query_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCopyFpgaImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5822,14 +5727,14 @@ func awsEc2query_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpCopyVolumes struct {
+type awsEc2query_deserializeOpCopyImage struct {
}
-func (*awsEc2query_deserializeOpCopyVolumes) ID() string {
+func (*awsEc2query_deserializeOpCopyImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCopyVolumes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCopyImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5847,9 +5752,9 @@ func (m *awsEc2query_deserializeOpCopyVolumes) HandleDeserialize(ctx context.Con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCopyVolumes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCopyImage(response, &metadata)
}
- output := &CopyVolumesOutput{}
+ output := &CopyImageOutput{}
out.Result = output
var buff [1024]byte
@@ -5870,7 +5775,7 @@ func (m *awsEc2query_deserializeOpCopyVolumes) HandleDeserialize(ctx context.Con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCopyVolumesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCopyImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5884,7 +5789,7 @@ func (m *awsEc2query_deserializeOpCopyVolumes) HandleDeserialize(ctx context.Con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCopyVolumes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCopyImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -5917,14 +5822,14 @@ func awsEc2query_deserializeOpErrorCopyVolumes(response *smithyhttp.Response, me
}
}
-type awsEc2query_deserializeOpCreateCapacityManagerDataExport struct {
+type awsEc2query_deserializeOpCopySnapshot struct {
}
-func (*awsEc2query_deserializeOpCreateCapacityManagerDataExport) ID() string {
+func (*awsEc2query_deserializeOpCopySnapshot) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCapacityManagerDataExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCopySnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -5942,9 +5847,9 @@ func (m *awsEc2query_deserializeOpCreateCapacityManagerDataExport) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityManagerDataExport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCopySnapshot(response, &metadata)
}
- output := &CreateCapacityManagerDataExportOutput{}
+ output := &CopySnapshotOutput{}
out.Result = output
var buff [1024]byte
@@ -5965,7 +5870,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityManagerDataExport) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCapacityManagerDataExportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCopySnapshotOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -5979,7 +5884,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityManagerDataExport) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCapacityManagerDataExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCopySnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6012,14 +5917,14 @@ func awsEc2query_deserializeOpErrorCreateCapacityManagerDataExport(response *smi
}
}
-type awsEc2query_deserializeOpCreateCapacityReservation struct {
+type awsEc2query_deserializeOpCopyVolumes struct {
}
-func (*awsEc2query_deserializeOpCreateCapacityReservation) ID() string {
+func (*awsEc2query_deserializeOpCopyVolumes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCopyVolumes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6037,9 +5942,9 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservation) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCopyVolumes(response, &metadata)
}
- output := &CreateCapacityReservationOutput{}
+ output := &CopyVolumesOutput{}
out.Result = output
var buff [1024]byte
@@ -6060,7 +5965,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservation) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCapacityReservationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCopyVolumesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6074,7 +5979,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservation) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCopyVolumes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6107,14 +6012,14 @@ func awsEc2query_deserializeOpErrorCreateCapacityReservation(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateCapacityReservationBySplitting struct {
+type awsEc2query_deserializeOpCreateApplicationStatusCheck struct {
}
-func (*awsEc2query_deserializeOpCreateCapacityReservationBySplitting) ID() string {
+func (*awsEc2query_deserializeOpCreateApplicationStatusCheck) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCapacityReservationBySplitting) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateApplicationStatusCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6132,9 +6037,9 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationBySplitting) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservationBySplitting(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateApplicationStatusCheck(response, &metadata)
}
- output := &CreateCapacityReservationBySplittingOutput{}
+ output := &CreateApplicationStatusCheckOutput{}
out.Result = output
var buff [1024]byte
@@ -6155,7 +6060,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationBySplitting) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCapacityReservationBySplittingOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateApplicationStatusCheckOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6169,7 +6074,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationBySplitting) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCapacityReservationBySplitting(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateApplicationStatusCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6202,14 +6107,14 @@ func awsEc2query_deserializeOpErrorCreateCapacityReservationBySplitting(response
}
}
-type awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote struct {
+type awsEc2query_deserializeOpCreateCapacityManagerDataExport struct {
}
-func (*awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) ID() string {
+func (*awsEc2query_deserializeOpCreateCapacityManagerDataExport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCapacityManagerDataExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6227,9 +6132,9 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservationCancellationQuote(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityManagerDataExport(response, &metadata)
}
- output := &CreateCapacityReservationCancellationQuoteOutput{}
+ output := &CreateCapacityManagerDataExportOutput{}
out.Result = output
var buff [1024]byte
@@ -6250,7 +6155,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCapacityReservationCancellationQuoteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCapacityManagerDataExportOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6264,7 +6169,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCapacityReservationCancellationQuote(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCapacityManagerDataExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6297,14 +6202,14 @@ func awsEc2query_deserializeOpErrorCreateCapacityReservationCancellationQuote(re
}
}
-type awsEc2query_deserializeOpCreateCapacityReservationFleet struct {
+type awsEc2query_deserializeOpCreateCapacityReservation struct {
}
-func (*awsEc2query_deserializeOpCreateCapacityReservationFleet) ID() string {
+func (*awsEc2query_deserializeOpCreateCapacityReservation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCapacityReservationFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6322,9 +6227,9 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationFleet) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservationFleet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservation(response, &metadata)
}
- output := &CreateCapacityReservationFleetOutput{}
+ output := &CreateCapacityReservationOutput{}
out.Result = output
var buff [1024]byte
@@ -6345,7 +6250,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationFleet) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCapacityReservationFleetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCapacityReservationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6359,7 +6264,7 @@ func (m *awsEc2query_deserializeOpCreateCapacityReservationFleet) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCapacityReservationFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6392,14 +6297,14 @@ func awsEc2query_deserializeOpErrorCreateCapacityReservationFleet(response *smit
}
}
-type awsEc2query_deserializeOpCreateCarrierGateway struct {
+type awsEc2query_deserializeOpCreateCapacityReservationBySplitting struct {
}
-func (*awsEc2query_deserializeOpCreateCarrierGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateCapacityReservationBySplitting) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCarrierGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCapacityReservationBySplitting) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6417,9 +6322,9 @@ func (m *awsEc2query_deserializeOpCreateCarrierGateway) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCarrierGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservationBySplitting(response, &metadata)
}
- output := &CreateCarrierGatewayOutput{}
+ output := &CreateCapacityReservationBySplittingOutput{}
out.Result = output
var buff [1024]byte
@@ -6440,7 +6345,7 @@ func (m *awsEc2query_deserializeOpCreateCarrierGateway) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCarrierGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCapacityReservationBySplittingOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6454,7 +6359,7 @@ func (m *awsEc2query_deserializeOpCreateCarrierGateway) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCarrierGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCapacityReservationBySplitting(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6487,14 +6392,14 @@ func awsEc2query_deserializeOpErrorCreateCarrierGateway(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreateClientVpnEndpoint struct {
+type awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote struct {
}
-func (*awsEc2query_deserializeOpCreateClientVpnEndpoint) ID() string {
+func (*awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCapacityReservationCancellationQuote) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6512,9 +6417,9 @@ func (m *awsEc2query_deserializeOpCreateClientVpnEndpoint) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateClientVpnEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservationCancellationQuote(response, &metadata)
}
- output := &CreateClientVpnEndpointOutput{}
+ output := &CreateCapacityReservationCancellationQuoteOutput{}
out.Result = output
var buff [1024]byte
@@ -6535,7 +6440,7 @@ func (m *awsEc2query_deserializeOpCreateClientVpnEndpoint) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateClientVpnEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCapacityReservationCancellationQuoteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6549,7 +6454,7 @@ func (m *awsEc2query_deserializeOpCreateClientVpnEndpoint) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCapacityReservationCancellationQuote(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6582,14 +6487,14 @@ func awsEc2query_deserializeOpErrorCreateClientVpnEndpoint(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpCreateClientVpnRoute struct {
+type awsEc2query_deserializeOpCreateCapacityReservationFleet struct {
}
-func (*awsEc2query_deserializeOpCreateClientVpnRoute) ID() string {
+func (*awsEc2query_deserializeOpCreateCapacityReservationFleet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateClientVpnRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCapacityReservationFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6607,9 +6512,9 @@ func (m *awsEc2query_deserializeOpCreateClientVpnRoute) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateClientVpnRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCapacityReservationFleet(response, &metadata)
}
- output := &CreateClientVpnRouteOutput{}
+ output := &CreateCapacityReservationFleetOutput{}
out.Result = output
var buff [1024]byte
@@ -6630,7 +6535,7 @@ func (m *awsEc2query_deserializeOpCreateClientVpnRoute) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateClientVpnRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCapacityReservationFleetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6644,7 +6549,7 @@ func (m *awsEc2query_deserializeOpCreateClientVpnRoute) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateClientVpnRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCapacityReservationFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6677,14 +6582,14 @@ func awsEc2query_deserializeOpErrorCreateClientVpnRoute(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreateCoipCidr struct {
+type awsEc2query_deserializeOpCreateCarrierGateway struct {
}
-func (*awsEc2query_deserializeOpCreateCoipCidr) ID() string {
+func (*awsEc2query_deserializeOpCreateCarrierGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCarrierGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6702,9 +6607,9 @@ func (m *awsEc2query_deserializeOpCreateCoipCidr) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCoipCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCarrierGateway(response, &metadata)
}
- output := &CreateCoipCidrOutput{}
+ output := &CreateCarrierGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -6725,7 +6630,7 @@ func (m *awsEc2query_deserializeOpCreateCoipCidr) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCoipCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCarrierGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6739,7 +6644,7 @@ func (m *awsEc2query_deserializeOpCreateCoipCidr) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCarrierGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6772,14 +6677,14 @@ func awsEc2query_deserializeOpErrorCreateCoipCidr(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCreateCoipPool struct {
+type awsEc2query_deserializeOpCreateClientVpnEndpoint struct {
}
-func (*awsEc2query_deserializeOpCreateCoipPool) ID() string {
+func (*awsEc2query_deserializeOpCreateClientVpnEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCoipPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6797,9 +6702,9 @@ func (m *awsEc2query_deserializeOpCreateCoipPool) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCoipPool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateClientVpnEndpoint(response, &metadata)
}
- output := &CreateCoipPoolOutput{}
+ output := &CreateClientVpnEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -6820,7 +6725,7 @@ func (m *awsEc2query_deserializeOpCreateCoipPool) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCoipPoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateClientVpnEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6834,7 +6739,7 @@ func (m *awsEc2query_deserializeOpCreateCoipPool) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCoipPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6867,14 +6772,14 @@ func awsEc2query_deserializeOpErrorCreateCoipPool(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCreateCustomerGateway struct {
+type awsEc2query_deserializeOpCreateClientVpnRoute struct {
}
-func (*awsEc2query_deserializeOpCreateCustomerGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateClientVpnRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateCustomerGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateClientVpnRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6892,9 +6797,9 @@ func (m *awsEc2query_deserializeOpCreateCustomerGateway) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateCustomerGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateClientVpnRoute(response, &metadata)
}
- output := &CreateCustomerGatewayOutput{}
+ output := &CreateClientVpnRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -6915,7 +6820,7 @@ func (m *awsEc2query_deserializeOpCreateCustomerGateway) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateCustomerGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateClientVpnRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -6929,7 +6834,7 @@ func (m *awsEc2query_deserializeOpCreateCustomerGateway) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateCustomerGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateClientVpnRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -6962,14 +6867,14 @@ func awsEc2query_deserializeOpErrorCreateCustomerGateway(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpCreateDefaultSubnet struct {
+type awsEc2query_deserializeOpCreateCoipCidr struct {
}
-func (*awsEc2query_deserializeOpCreateDefaultSubnet) ID() string {
+func (*awsEc2query_deserializeOpCreateCoipCidr) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateDefaultSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -6987,9 +6892,9 @@ func (m *awsEc2query_deserializeOpCreateDefaultSubnet) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateDefaultSubnet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCoipCidr(response, &metadata)
}
- output := &CreateDefaultSubnetOutput{}
+ output := &CreateCoipCidrOutput{}
out.Result = output
var buff [1024]byte
@@ -7010,7 +6915,7 @@ func (m *awsEc2query_deserializeOpCreateDefaultSubnet) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateDefaultSubnetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCoipCidrOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7024,7 +6929,7 @@ func (m *awsEc2query_deserializeOpCreateDefaultSubnet) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateDefaultSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7057,14 +6962,14 @@ func awsEc2query_deserializeOpErrorCreateDefaultSubnet(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpCreateDefaultVpc struct {
+type awsEc2query_deserializeOpCreateCoipPool struct {
}
-func (*awsEc2query_deserializeOpCreateDefaultVpc) ID() string {
+func (*awsEc2query_deserializeOpCreateCoipPool) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateDefaultVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCoipPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7082,9 +6987,9 @@ func (m *awsEc2query_deserializeOpCreateDefaultVpc) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateDefaultVpc(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCoipPool(response, &metadata)
}
- output := &CreateDefaultVpcOutput{}
+ output := &CreateCoipPoolOutput{}
out.Result = output
var buff [1024]byte
@@ -7105,7 +7010,7 @@ func (m *awsEc2query_deserializeOpCreateDefaultVpc) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateDefaultVpcOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCoipPoolOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7119,7 +7024,7 @@ func (m *awsEc2query_deserializeOpCreateDefaultVpc) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateDefaultVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCoipPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7152,14 +7057,14 @@ func awsEc2query_deserializeOpErrorCreateDefaultVpc(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask struct {
+type awsEc2query_deserializeOpCreateCustomerGateway struct {
}
-func (*awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) ID() string {
+func (*awsEc2query_deserializeOpCreateCustomerGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateCustomerGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7177,9 +7082,9 @@ func (m *awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateDelegateMacVolumeOwnershipTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateCustomerGateway(response, &metadata)
}
- output := &CreateDelegateMacVolumeOwnershipTaskOutput{}
+ output := &CreateCustomerGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -7200,7 +7105,7 @@ func (m *awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateDelegateMacVolumeOwnershipTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateCustomerGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7214,7 +7119,7 @@ func (m *awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateDelegateMacVolumeOwnershipTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateCustomerGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7247,14 +7152,14 @@ func awsEc2query_deserializeOpErrorCreateDelegateMacVolumeOwnershipTask(response
}
}
-type awsEc2query_deserializeOpCreateDhcpOptions struct {
+type awsEc2query_deserializeOpCreateDefaultSubnet struct {
}
-func (*awsEc2query_deserializeOpCreateDhcpOptions) ID() string {
+func (*awsEc2query_deserializeOpCreateDefaultSubnet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateDefaultSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7272,9 +7177,9 @@ func (m *awsEc2query_deserializeOpCreateDhcpOptions) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateDhcpOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateDefaultSubnet(response, &metadata)
}
- output := &CreateDhcpOptionsOutput{}
+ output := &CreateDefaultSubnetOutput{}
out.Result = output
var buff [1024]byte
@@ -7295,7 +7200,7 @@ func (m *awsEc2query_deserializeOpCreateDhcpOptions) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateDhcpOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateDefaultSubnetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7309,7 +7214,7 @@ func (m *awsEc2query_deserializeOpCreateDhcpOptions) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateDefaultSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7342,14 +7247,14 @@ func awsEc2query_deserializeOpErrorCreateDhcpOptions(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpCreateEgressOnlyInternetGateway struct {
+type awsEc2query_deserializeOpCreateDefaultVpc struct {
}
-func (*awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateDefaultVpc) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateDefaultVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7367,9 +7272,9 @@ func (m *awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateEgressOnlyInternetGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateDefaultVpc(response, &metadata)
}
- output := &CreateEgressOnlyInternetGatewayOutput{}
+ output := &CreateDefaultVpcOutput{}
out.Result = output
var buff [1024]byte
@@ -7390,7 +7295,7 @@ func (m *awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateEgressOnlyInternetGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateDefaultVpcOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7404,7 +7309,7 @@ func (m *awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateEgressOnlyInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateDefaultVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7437,14 +7342,14 @@ func awsEc2query_deserializeOpErrorCreateEgressOnlyInternetGateway(response *smi
}
}
-type awsEc2query_deserializeOpCreateFleet struct {
+type awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask struct {
}
-func (*awsEc2query_deserializeOpCreateFleet) ID() string {
+func (*awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateDelegateMacVolumeOwnershipTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7462,9 +7367,9 @@ func (m *awsEc2query_deserializeOpCreateFleet) HandleDeserialize(ctx context.Con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateFleet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateDelegateMacVolumeOwnershipTask(response, &metadata)
}
- output := &CreateFleetOutput{}
+ output := &CreateDelegateMacVolumeOwnershipTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -7485,7 +7390,7 @@ func (m *awsEc2query_deserializeOpCreateFleet) HandleDeserialize(ctx context.Con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateFleetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateDelegateMacVolumeOwnershipTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7499,7 +7404,7 @@ func (m *awsEc2query_deserializeOpCreateFleet) HandleDeserialize(ctx context.Con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateDelegateMacVolumeOwnershipTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7532,14 +7437,14 @@ func awsEc2query_deserializeOpErrorCreateFleet(response *smithyhttp.Response, me
}
}
-type awsEc2query_deserializeOpCreateFlowLogs struct {
+type awsEc2query_deserializeOpCreateDhcpOptions struct {
}
-func (*awsEc2query_deserializeOpCreateFlowLogs) ID() string {
+func (*awsEc2query_deserializeOpCreateDhcpOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateFlowLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7557,9 +7462,9 @@ func (m *awsEc2query_deserializeOpCreateFlowLogs) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateFlowLogs(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateDhcpOptions(response, &metadata)
}
- output := &CreateFlowLogsOutput{}
+ output := &CreateDhcpOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -7580,7 +7485,7 @@ func (m *awsEc2query_deserializeOpCreateFlowLogs) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateFlowLogsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateDhcpOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7594,7 +7499,7 @@ func (m *awsEc2query_deserializeOpCreateFlowLogs) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateFlowLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7627,14 +7532,14 @@ func awsEc2query_deserializeOpErrorCreateFlowLogs(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCreateFpgaImage struct {
+type awsEc2query_deserializeOpCreateEgressOnlyInternetGateway struct {
}
-func (*awsEc2query_deserializeOpCreateFpgaImage) ID() string {
+func (*awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateFpgaImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateEgressOnlyInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7652,9 +7557,9 @@ func (m *awsEc2query_deserializeOpCreateFpgaImage) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateFpgaImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateEgressOnlyInternetGateway(response, &metadata)
}
- output := &CreateFpgaImageOutput{}
+ output := &CreateEgressOnlyInternetGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -7675,7 +7580,7 @@ func (m *awsEc2query_deserializeOpCreateFpgaImage) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateFpgaImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateEgressOnlyInternetGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7689,7 +7594,7 @@ func (m *awsEc2query_deserializeOpCreateFpgaImage) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateFpgaImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateEgressOnlyInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7722,14 +7627,14 @@ func awsEc2query_deserializeOpErrorCreateFpgaImage(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpCreateImage struct {
+type awsEc2query_deserializeOpCreateFleet struct {
}
-func (*awsEc2query_deserializeOpCreateImage) ID() string {
+func (*awsEc2query_deserializeOpCreateFleet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7747,9 +7652,9 @@ func (m *awsEc2query_deserializeOpCreateImage) HandleDeserialize(ctx context.Con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateFleet(response, &metadata)
}
- output := &CreateImageOutput{}
+ output := &CreateFleetOutput{}
out.Result = output
var buff [1024]byte
@@ -7770,7 +7675,7 @@ func (m *awsEc2query_deserializeOpCreateImage) HandleDeserialize(ctx context.Con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateFleetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7784,7 +7689,7 @@ func (m *awsEc2query_deserializeOpCreateImage) HandleDeserialize(ctx context.Con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7817,14 +7722,14 @@ func awsEc2query_deserializeOpErrorCreateImage(response *smithyhttp.Response, me
}
}
-type awsEc2query_deserializeOpCreateImageUsageReport struct {
+type awsEc2query_deserializeOpCreateFlowLogs struct {
}
-func (*awsEc2query_deserializeOpCreateImageUsageReport) ID() string {
+func (*awsEc2query_deserializeOpCreateFlowLogs) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateImageUsageReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateFlowLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7842,9 +7747,9 @@ func (m *awsEc2query_deserializeOpCreateImageUsageReport) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateImageUsageReport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateFlowLogs(response, &metadata)
}
- output := &CreateImageUsageReportOutput{}
+ output := &CreateFlowLogsOutput{}
out.Result = output
var buff [1024]byte
@@ -7865,7 +7770,7 @@ func (m *awsEc2query_deserializeOpCreateImageUsageReport) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateImageUsageReportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateFlowLogsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7879,7 +7784,7 @@ func (m *awsEc2query_deserializeOpCreateImageUsageReport) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateImageUsageReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateFlowLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -7912,14 +7817,14 @@ func awsEc2query_deserializeOpErrorCreateImageUsageReport(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpCreateInstanceConnectEndpoint struct {
+type awsEc2query_deserializeOpCreateFpgaImage struct {
}
-func (*awsEc2query_deserializeOpCreateInstanceConnectEndpoint) ID() string {
+func (*awsEc2query_deserializeOpCreateFpgaImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateFpgaImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -7937,9 +7842,9 @@ func (m *awsEc2query_deserializeOpCreateInstanceConnectEndpoint) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateInstanceConnectEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateFpgaImage(response, &metadata)
}
- output := &CreateInstanceConnectEndpointOutput{}
+ output := &CreateFpgaImageOutput{}
out.Result = output
var buff [1024]byte
@@ -7960,7 +7865,7 @@ func (m *awsEc2query_deserializeOpCreateInstanceConnectEndpoint) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateInstanceConnectEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateFpgaImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -7974,7 +7879,7 @@ func (m *awsEc2query_deserializeOpCreateInstanceConnectEndpoint) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateFpgaImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8007,14 +7912,14 @@ func awsEc2query_deserializeOpErrorCreateInstanceConnectEndpoint(response *smith
}
}
-type awsEc2query_deserializeOpCreateInstanceEventWindow struct {
+type awsEc2query_deserializeOpCreateImage struct {
}
-func (*awsEc2query_deserializeOpCreateInstanceEventWindow) ID() string {
+func (*awsEc2query_deserializeOpCreateImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8032,9 +7937,9 @@ func (m *awsEc2query_deserializeOpCreateInstanceEventWindow) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateInstanceEventWindow(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateImage(response, &metadata)
}
- output := &CreateInstanceEventWindowOutput{}
+ output := &CreateImageOutput{}
out.Result = output
var buff [1024]byte
@@ -8055,7 +7960,7 @@ func (m *awsEc2query_deserializeOpCreateInstanceEventWindow) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateInstanceEventWindowOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8069,7 +7974,7 @@ func (m *awsEc2query_deserializeOpCreateInstanceEventWindow) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8102,14 +8007,14 @@ func awsEc2query_deserializeOpErrorCreateInstanceEventWindow(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateInstanceExportTask struct {
+type awsEc2query_deserializeOpCreateImageUsageReport struct {
}
-func (*awsEc2query_deserializeOpCreateInstanceExportTask) ID() string {
+func (*awsEc2query_deserializeOpCreateImageUsageReport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateInstanceExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateImageUsageReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8127,9 +8032,9 @@ func (m *awsEc2query_deserializeOpCreateInstanceExportTask) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateInstanceExportTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateImageUsageReport(response, &metadata)
}
- output := &CreateInstanceExportTaskOutput{}
+ output := &CreateImageUsageReportOutput{}
out.Result = output
var buff [1024]byte
@@ -8150,7 +8055,7 @@ func (m *awsEc2query_deserializeOpCreateInstanceExportTask) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateInstanceExportTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateImageUsageReportOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8164,7 +8069,7 @@ func (m *awsEc2query_deserializeOpCreateInstanceExportTask) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateInstanceExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateImageUsageReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8197,14 +8102,14 @@ func awsEc2query_deserializeOpErrorCreateInstanceExportTask(response *smithyhttp
}
}
-type awsEc2query_deserializeOpCreateInternetGateway struct {
+type awsEc2query_deserializeOpCreateInstanceConnectEndpoint struct {
}
-func (*awsEc2query_deserializeOpCreateInternetGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateInstanceConnectEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8222,9 +8127,9 @@ func (m *awsEc2query_deserializeOpCreateInternetGateway) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateInternetGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateInstanceConnectEndpoint(response, &metadata)
}
- output := &CreateInternetGatewayOutput{}
+ output := &CreateInstanceConnectEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -8245,7 +8150,7 @@ func (m *awsEc2query_deserializeOpCreateInternetGateway) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateInternetGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateInstanceConnectEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8259,7 +8164,7 @@ func (m *awsEc2query_deserializeOpCreateInternetGateway) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8292,14 +8197,14 @@ func awsEc2query_deserializeOpErrorCreateInternetGateway(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocation struct {
+type awsEc2query_deserializeOpCreateInstanceEventWindow struct {
}
-func (*awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocation) ID() string {
+func (*awsEc2query_deserializeOpCreateInstanceEventWindow) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8317,9 +8222,9 @@ func (m *awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocati
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateInterruptibleCapacityReservationAllocation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateInstanceEventWindow(response, &metadata)
}
- output := &CreateInterruptibleCapacityReservationAllocationOutput{}
+ output := &CreateInstanceEventWindowOutput{}
out.Result = output
var buff [1024]byte
@@ -8340,7 +8245,7 @@ func (m *awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocati
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateInterruptibleCapacityReservationAllocationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateInstanceEventWindowOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8354,7 +8259,7 @@ func (m *awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocati
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateInterruptibleCapacityReservationAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8387,14 +8292,14 @@ func awsEc2query_deserializeOpErrorCreateInterruptibleCapacityReservationAllocat
}
}
-type awsEc2query_deserializeOpCreateIpam struct {
+type awsEc2query_deserializeOpCreateInstanceExportTask struct {
}
-func (*awsEc2query_deserializeOpCreateIpam) ID() string {
+func (*awsEc2query_deserializeOpCreateInstanceExportTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateInstanceExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8412,9 +8317,9 @@ func (m *awsEc2query_deserializeOpCreateIpam) HandleDeserialize(ctx context.Cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpam(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateInstanceExportTask(response, &metadata)
}
- output := &CreateIpamOutput{}
+ output := &CreateInstanceExportTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -8435,7 +8340,7 @@ func (m *awsEc2query_deserializeOpCreateIpam) HandleDeserialize(ctx context.Cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateInstanceExportTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8449,7 +8354,7 @@ func (m *awsEc2query_deserializeOpCreateIpam) HandleDeserialize(ctx context.Cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateInstanceExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8482,14 +8387,14 @@ func awsEc2query_deserializeOpErrorCreateIpam(response *smithyhttp.Response, met
}
}
-type awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken struct {
+type awsEc2query_deserializeOpCreateInternetGateway struct {
}
-func (*awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) ID() string {
+func (*awsEc2query_deserializeOpCreateInternetGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8507,9 +8412,9 @@ func (m *awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamExternalResourceVerificationToken(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateInternetGateway(response, &metadata)
}
- output := &CreateIpamExternalResourceVerificationTokenOutput{}
+ output := &CreateInternetGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -8530,7 +8435,7 @@ func (m *awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamExternalResourceVerificationTokenOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateInternetGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8544,7 +8449,7 @@ func (m *awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamExternalResourceVerificationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8577,14 +8482,14 @@ func awsEc2query_deserializeOpErrorCreateIpamExternalResourceVerificationToken(r
}
}
-type awsEc2query_deserializeOpCreateIpamPolicy struct {
+type awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocation struct {
}
-func (*awsEc2query_deserializeOpCreateIpamPolicy) ID() string {
+func (*awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateInterruptibleCapacityReservationAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8602,9 +8507,9 @@ func (m *awsEc2query_deserializeOpCreateIpamPolicy) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPolicy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateInterruptibleCapacityReservationAllocation(response, &metadata)
}
- output := &CreateIpamPolicyOutput{}
+ output := &CreateInterruptibleCapacityReservationAllocationOutput{}
out.Result = output
var buff [1024]byte
@@ -8625,7 +8530,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPolicy) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamPolicyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateInterruptibleCapacityReservationAllocationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8639,7 +8544,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPolicy) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateInterruptibleCapacityReservationAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8672,14 +8577,14 @@ func awsEc2query_deserializeOpErrorCreateIpamPolicy(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCreateIpamPool struct {
+type awsEc2query_deserializeOpCreateIpam struct {
}
-func (*awsEc2query_deserializeOpCreateIpamPool) ID() string {
+func (*awsEc2query_deserializeOpCreateIpam) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8697,9 +8602,9 @@ func (m *awsEc2query_deserializeOpCreateIpamPool) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpam(response, &metadata)
}
- output := &CreateIpamPoolOutput{}
+ output := &CreateIpamOutput{}
out.Result = output
var buff [1024]byte
@@ -8720,7 +8625,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPool) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamPoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8734,7 +8639,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPool) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8767,14 +8672,14 @@ func awsEc2query_deserializeOpErrorCreateIpamPool(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCreateIpamPrefixListResolver struct {
+type awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken struct {
}
-func (*awsEc2query_deserializeOpCreateIpamPrefixListResolver) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamExternalResourceVerificationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8792,9 +8697,9 @@ func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolver) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPrefixListResolver(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamExternalResourceVerificationToken(response, &metadata)
}
- output := &CreateIpamPrefixListResolverOutput{}
+ output := &CreateIpamExternalResourceVerificationTokenOutput{}
out.Result = output
var buff [1024]byte
@@ -8815,7 +8720,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolver) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamPrefixListResolverOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamExternalResourceVerificationTokenOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8829,7 +8734,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolver) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamExternalResourceVerificationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8862,14 +8767,14 @@ func awsEc2query_deserializeOpErrorCreateIpamPrefixListResolver(response *smithy
}
}
-type awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget struct {
+type awsEc2query_deserializeOpCreateIpamPolicy struct {
}
-func (*awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamPolicy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8887,9 +8792,9 @@ func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPrefixListResolverTarget(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPolicy(response, &metadata)
}
- output := &CreateIpamPrefixListResolverTargetOutput{}
+ output := &CreateIpamPolicyOutput{}
out.Result = output
var buff [1024]byte
@@ -8910,7 +8815,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamPrefixListResolverTargetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamPolicyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -8924,7 +8829,7 @@ func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -8957,14 +8862,14 @@ func awsEc2query_deserializeOpErrorCreateIpamPrefixListResolverTarget(response *
}
}
-type awsEc2query_deserializeOpCreateIpamResourceDiscovery struct {
+type awsEc2query_deserializeOpCreateIpamPool struct {
}
-func (*awsEc2query_deserializeOpCreateIpamResourceDiscovery) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamPool) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -8982,9 +8887,9 @@ func (m *awsEc2query_deserializeOpCreateIpamResourceDiscovery) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPool(response, &metadata)
}
- output := &CreateIpamResourceDiscoveryOutput{}
+ output := &CreateIpamPoolOutput{}
out.Result = output
var buff [1024]byte
@@ -9005,7 +8910,7 @@ func (m *awsEc2query_deserializeOpCreateIpamResourceDiscovery) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamResourceDiscoveryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamPoolOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9019,7 +8924,7 @@ func (m *awsEc2query_deserializeOpCreateIpamResourceDiscovery) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9052,14 +8957,14 @@ func awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response *smithyh
}
}
-type awsEc2query_deserializeOpCreateIpamScope struct {
+type awsEc2query_deserializeOpCreateIpamPrefixListResolver struct {
}
-func (*awsEc2query_deserializeOpCreateIpamScope) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamPrefixListResolver) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9077,9 +8982,9 @@ func (m *awsEc2query_deserializeOpCreateIpamScope) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateIpamScope(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPrefixListResolver(response, &metadata)
}
- output := &CreateIpamScopeOutput{}
+ output := &CreateIpamPrefixListResolverOutput{}
out.Result = output
var buff [1024]byte
@@ -9100,7 +9005,7 @@ func (m *awsEc2query_deserializeOpCreateIpamScope) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateIpamScopeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamPrefixListResolverOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9114,7 +9019,7 @@ func (m *awsEc2query_deserializeOpCreateIpamScope) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9147,14 +9052,14 @@ func awsEc2query_deserializeOpErrorCreateIpamScope(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpCreateKeyPair struct {
+type awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget struct {
}
-func (*awsEc2query_deserializeOpCreateKeyPair) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9172,9 +9077,9 @@ func (m *awsEc2query_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateKeyPair(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamPrefixListResolverTarget(response, &metadata)
}
- output := &CreateKeyPairOutput{}
+ output := &CreateIpamPrefixListResolverTargetOutput{}
out.Result = output
var buff [1024]byte
@@ -9195,7 +9100,7 @@ func (m *awsEc2query_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateKeyPairOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamPrefixListResolverTargetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9209,7 +9114,7 @@ func (m *awsEc2query_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9242,14 +9147,14 @@ func awsEc2query_deserializeOpErrorCreateKeyPair(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCreateLaunchTemplate struct {
+type awsEc2query_deserializeOpCreateIpamResourceDiscovery struct {
}
-func (*awsEc2query_deserializeOpCreateLaunchTemplate) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamResourceDiscovery) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9267,9 +9172,9 @@ func (m *awsEc2query_deserializeOpCreateLaunchTemplate) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLaunchTemplate(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response, &metadata)
}
- output := &CreateLaunchTemplateOutput{}
+ output := &CreateIpamResourceDiscoveryOutput{}
out.Result = output
var buff [1024]byte
@@ -9290,7 +9195,7 @@ func (m *awsEc2query_deserializeOpCreateLaunchTemplate) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLaunchTemplateOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamResourceDiscoveryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9304,7 +9209,7 @@ func (m *awsEc2query_deserializeOpCreateLaunchTemplate) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9337,14 +9242,14 @@ func awsEc2query_deserializeOpErrorCreateLaunchTemplate(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreateLaunchTemplateVersion struct {
+type awsEc2query_deserializeOpCreateIpamScope struct {
}
-func (*awsEc2query_deserializeOpCreateLaunchTemplateVersion) ID() string {
+func (*awsEc2query_deserializeOpCreateIpamScope) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLaunchTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9362,9 +9267,9 @@ func (m *awsEc2query_deserializeOpCreateLaunchTemplateVersion) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLaunchTemplateVersion(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateIpamScope(response, &metadata)
}
- output := &CreateLaunchTemplateVersionOutput{}
+ output := &CreateIpamScopeOutput{}
out.Result = output
var buff [1024]byte
@@ -9385,7 +9290,7 @@ func (m *awsEc2query_deserializeOpCreateLaunchTemplateVersion) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLaunchTemplateVersionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateIpamScopeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9399,7 +9304,7 @@ func (m *awsEc2query_deserializeOpCreateLaunchTemplateVersion) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLaunchTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9432,14 +9337,14 @@ func awsEc2query_deserializeOpErrorCreateLaunchTemplateVersion(response *smithyh
}
}
-type awsEc2query_deserializeOpCreateLocalGatewayRoute struct {
+type awsEc2query_deserializeOpCreateKeyPair struct {
}
-func (*awsEc2query_deserializeOpCreateLocalGatewayRoute) ID() string {
+func (*awsEc2query_deserializeOpCreateKeyPair) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9457,9 +9362,9 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRoute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateKeyPair(response, &metadata)
}
- output := &CreateLocalGatewayRouteOutput{}
+ output := &CreateKeyPairOutput{}
out.Result = output
var buff [1024]byte
@@ -9480,7 +9385,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRoute) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateKeyPairOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9494,7 +9399,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRoute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9527,14 +9432,14 @@ func awsEc2query_deserializeOpErrorCreateLocalGatewayRoute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpCreateLocalGatewayRouteTable struct {
+type awsEc2query_deserializeOpCreateLaunchTemplate struct {
}
-func (*awsEc2query_deserializeOpCreateLocalGatewayRouteTable) ID() string {
+func (*awsEc2query_deserializeOpCreateLaunchTemplate) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9552,9 +9457,9 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTable) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLaunchTemplate(response, &metadata)
}
- output := &CreateLocalGatewayRouteTableOutput{}
+ output := &CreateLaunchTemplateOutput{}
out.Result = output
var buff [1024]byte
@@ -9575,7 +9480,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTable) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLaunchTemplateOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9589,7 +9494,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTable) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9622,14 +9527,14 @@ func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTable(response *smithy
}
}
-type awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
+type awsEc2query_deserializeOpCreateLaunchTemplateVersion struct {
}
-func (*awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation) ID() string {
+func (*awsEc2query_deserializeOpCreateLaunchTemplateVersion) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLaunchTemplateVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9647,9 +9552,9 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGr
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLaunchTemplateVersion(response, &metadata)
}
- output := &CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput{}
+ output := &CreateLaunchTemplateVersionOutput{}
out.Result = output
var buff [1024]byte
@@ -9670,7 +9575,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGr
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLaunchTemplateVersionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9684,7 +9589,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGr
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLaunchTemplateVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9717,14 +9622,14 @@ func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVirtualInterfaceG
}
}
-type awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation struct {
+type awsEc2query_deserializeOpCreateLocalGatewayRoute struct {
}
-func (*awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) ID() string {
+func (*awsEc2query_deserializeOpCreateLocalGatewayRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9742,9 +9647,9 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVpcAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRoute(response, &metadata)
}
- output := &CreateLocalGatewayRouteTableVpcAssociationOutput{}
+ output := &CreateLocalGatewayRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -9765,7 +9670,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteTableVpcAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9779,7 +9684,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVpcAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9812,14 +9717,14 @@ func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVpcAssociation(re
}
}
-type awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface struct {
+type awsEc2query_deserializeOpCreateLocalGatewayRouteTable struct {
}
-func (*awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) ID() string {
+func (*awsEc2query_deserializeOpCreateLocalGatewayRouteTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9837,9 +9742,9 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTable(response, &metadata)
}
- output := &CreateLocalGatewayVirtualInterfaceOutput{}
+ output := &CreateLocalGatewayRouteTableOutput{}
out.Result = output
var buff [1024]byte
@@ -9860,7 +9765,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLocalGatewayVirtualInterfaceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9874,7 +9779,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -9907,14 +9812,14 @@ func awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterface(response *
}
}
-type awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup struct {
+type awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
}
-func (*awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) ID() string {
+func (*awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -9932,9 +9837,9 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterfaceGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response, &metadata)
}
- output := &CreateLocalGatewayVirtualInterfaceGroupOutput{}
+ output := &CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput{}
out.Result = output
var buff [1024]byte
@@ -9955,7 +9860,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateLocalGatewayVirtualInterfaceGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -9969,7 +9874,7 @@ func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterfaceGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10002,14 +9907,14 @@ func awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterfaceGroup(respo
}
}
-type awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModificationTask struct {
+type awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation struct {
}
-func (*awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModificationTask) ID() string {
+func (*awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModificationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLocalGatewayRouteTableVpcAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10027,9 +9932,9 @@ func (m *awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModification
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateMacSystemIntegrityProtectionModificationTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVpcAssociation(response, &metadata)
}
- output := &CreateMacSystemIntegrityProtectionModificationTaskOutput{}
+ output := &CreateLocalGatewayRouteTableVpcAssociationOutput{}
out.Result = output
var buff [1024]byte
@@ -10050,7 +9955,7 @@ func (m *awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModification
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateMacSystemIntegrityProtectionModificationTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLocalGatewayRouteTableVpcAssociationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10064,7 +9969,7 @@ func (m *awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModification
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateMacSystemIntegrityProtectionModificationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLocalGatewayRouteTableVpcAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10097,14 +10002,14 @@ func awsEc2query_deserializeOpErrorCreateMacSystemIntegrityProtectionModificatio
}
}
-type awsEc2query_deserializeOpCreateManagedPrefixList struct {
+type awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface struct {
}
-func (*awsEc2query_deserializeOpCreateManagedPrefixList) ID() string {
+func (*awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10122,9 +10027,9 @@ func (m *awsEc2query_deserializeOpCreateManagedPrefixList) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateManagedPrefixList(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterface(response, &metadata)
}
- output := &CreateManagedPrefixListOutput{}
+ output := &CreateLocalGatewayVirtualInterfaceOutput{}
out.Result = output
var buff [1024]byte
@@ -10145,7 +10050,7 @@ func (m *awsEc2query_deserializeOpCreateManagedPrefixList) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateManagedPrefixListOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLocalGatewayVirtualInterfaceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10159,7 +10064,7 @@ func (m *awsEc2query_deserializeOpCreateManagedPrefixList) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10192,14 +10097,14 @@ func awsEc2query_deserializeOpErrorCreateManagedPrefixList(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpCreateNatGateway struct {
+type awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup struct {
}
-func (*awsEc2query_deserializeOpCreateNatGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNatGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateLocalGatewayVirtualInterfaceGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10217,9 +10122,9 @@ func (m *awsEc2query_deserializeOpCreateNatGateway) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNatGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterfaceGroup(response, &metadata)
}
- output := &CreateNatGatewayOutput{}
+ output := &CreateLocalGatewayVirtualInterfaceGroupOutput{}
out.Result = output
var buff [1024]byte
@@ -10240,7 +10145,7 @@ func (m *awsEc2query_deserializeOpCreateNatGateway) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateNatGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateLocalGatewayVirtualInterfaceGroupOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10254,7 +10159,7 @@ func (m *awsEc2query_deserializeOpCreateNatGateway) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNatGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateLocalGatewayVirtualInterfaceGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10287,14 +10192,14 @@ func awsEc2query_deserializeOpErrorCreateNatGateway(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCreateNetworkAcl struct {
+type awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModificationTask struct {
}
-func (*awsEc2query_deserializeOpCreateNetworkAcl) ID() string {
+func (*awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModificationTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNetworkAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateMacSystemIntegrityProtectionModificationTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10312,9 +10217,9 @@ func (m *awsEc2query_deserializeOpCreateNetworkAcl) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkAcl(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateMacSystemIntegrityProtectionModificationTask(response, &metadata)
}
- output := &CreateNetworkAclOutput{}
+ output := &CreateMacSystemIntegrityProtectionModificationTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -10335,7 +10240,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkAcl) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateNetworkAclOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateMacSystemIntegrityProtectionModificationTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10349,7 +10254,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkAcl) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNetworkAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateMacSystemIntegrityProtectionModificationTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10382,14 +10287,14 @@ func awsEc2query_deserializeOpErrorCreateNetworkAcl(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCreateNetworkAclEntry struct {
+type awsEc2query_deserializeOpCreateManagedPrefixList struct {
}
-func (*awsEc2query_deserializeOpCreateNetworkAclEntry) ID() string {
+func (*awsEc2query_deserializeOpCreateManagedPrefixList) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10407,21 +10312,44 @@ func (m *awsEc2query_deserializeOpCreateNetworkAclEntry) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkAclEntry(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateManagedPrefixList(response, &metadata)
}
- output := &CreateNetworkAclEntryOutput{}
+ output := &CreateManagedPrefixListOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentCreateManagedPrefixListOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10454,14 +10382,14 @@ func awsEc2query_deserializeOpErrorCreateNetworkAclEntry(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpCreateNetworkInsightsAccessScope struct {
+type awsEc2query_deserializeOpCreateNatGateway struct {
}
-func (*awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) ID() string {
+func (*awsEc2query_deserializeOpCreateNatGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNatGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10479,9 +10407,9 @@ func (m *awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInsightsAccessScope(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNatGateway(response, &metadata)
}
- output := &CreateNetworkInsightsAccessScopeOutput{}
+ output := &CreateNatGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -10502,7 +10430,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateNetworkInsightsAccessScopeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateNatGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10516,7 +10444,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNetworkInsightsAccessScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNatGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10549,14 +10477,14 @@ func awsEc2query_deserializeOpErrorCreateNetworkInsightsAccessScope(response *sm
}
}
-type awsEc2query_deserializeOpCreateNetworkInsightsPath struct {
+type awsEc2query_deserializeOpCreateNetworkAcl struct {
}
-func (*awsEc2query_deserializeOpCreateNetworkInsightsPath) ID() string {
+func (*awsEc2query_deserializeOpCreateNetworkAcl) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNetworkInsightsPath) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNetworkAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10574,9 +10502,9 @@ func (m *awsEc2query_deserializeOpCreateNetworkInsightsPath) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInsightsPath(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkAcl(response, &metadata)
}
- output := &CreateNetworkInsightsPathOutput{}
+ output := &CreateNetworkAclOutput{}
out.Result = output
var buff [1024]byte
@@ -10597,7 +10525,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkInsightsPath) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateNetworkInsightsPathOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateNetworkAclOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10611,7 +10539,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkInsightsPath) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNetworkInsightsPath(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNetworkAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10644,14 +10572,14 @@ func awsEc2query_deserializeOpErrorCreateNetworkInsightsPath(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateNetworkInterface struct {
+type awsEc2query_deserializeOpCreateNetworkAclEntry struct {
}
-func (*awsEc2query_deserializeOpCreateNetworkInterface) ID() string {
+func (*awsEc2query_deserializeOpCreateNetworkAclEntry) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10669,44 +10597,21 @@ func (m *awsEc2query_deserializeOpCreateNetworkInterface) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkAclEntry(response, &metadata)
}
- output := &CreateNetworkInterfaceOutput{}
+ output := &CreateNetworkAclEntryOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateNetworkInterfaceOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10739,14 +10644,14 @@ func awsEc2query_deserializeOpErrorCreateNetworkInterface(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpCreateNetworkInterfacePermission struct {
+type awsEc2query_deserializeOpCreateNetworkInsightsAccessScope struct {
}
-func (*awsEc2query_deserializeOpCreateNetworkInterfacePermission) ID() string {
+func (*awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateNetworkInterfacePermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNetworkInsightsAccessScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10764,9 +10669,9 @@ func (m *awsEc2query_deserializeOpCreateNetworkInterfacePermission) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInterfacePermission(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInsightsAccessScope(response, &metadata)
}
- output := &CreateNetworkInterfacePermissionOutput{}
+ output := &CreateNetworkInsightsAccessScopeOutput{}
out.Result = output
var buff [1024]byte
@@ -10787,7 +10692,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkInterfacePermission) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateNetworkInterfacePermissionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateNetworkInsightsAccessScopeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10801,7 +10706,7 @@ func (m *awsEc2query_deserializeOpCreateNetworkInterfacePermission) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateNetworkInterfacePermission(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNetworkInsightsAccessScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10834,14 +10739,14 @@ func awsEc2query_deserializeOpErrorCreateNetworkInterfacePermission(response *sm
}
}
-type awsEc2query_deserializeOpCreatePlacementGroup struct {
+type awsEc2query_deserializeOpCreateNetworkInsightsPath struct {
}
-func (*awsEc2query_deserializeOpCreatePlacementGroup) ID() string {
+func (*awsEc2query_deserializeOpCreateNetworkInsightsPath) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreatePlacementGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNetworkInsightsPath) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10859,9 +10764,9 @@ func (m *awsEc2query_deserializeOpCreatePlacementGroup) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreatePlacementGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInsightsPath(response, &metadata)
}
- output := &CreatePlacementGroupOutput{}
+ output := &CreateNetworkInsightsPathOutput{}
out.Result = output
var buff [1024]byte
@@ -10882,7 +10787,7 @@ func (m *awsEc2query_deserializeOpCreatePlacementGroup) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreatePlacementGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateNetworkInsightsPathOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10896,7 +10801,7 @@ func (m *awsEc2query_deserializeOpCreatePlacementGroup) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreatePlacementGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNetworkInsightsPath(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -10929,14 +10834,14 @@ func awsEc2query_deserializeOpErrorCreatePlacementGroup(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreatePublicIpv4Pool struct {
+type awsEc2query_deserializeOpCreateNetworkInterface struct {
}
-func (*awsEc2query_deserializeOpCreatePublicIpv4Pool) ID() string {
+func (*awsEc2query_deserializeOpCreateNetworkInterface) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreatePublicIpv4Pool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -10954,9 +10859,9 @@ func (m *awsEc2query_deserializeOpCreatePublicIpv4Pool) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreatePublicIpv4Pool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInterface(response, &metadata)
}
- output := &CreatePublicIpv4PoolOutput{}
+ output := &CreateNetworkInterfaceOutput{}
out.Result = output
var buff [1024]byte
@@ -10977,7 +10882,7 @@ func (m *awsEc2query_deserializeOpCreatePublicIpv4Pool) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateNetworkInterfaceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -10991,7 +10896,7 @@ func (m *awsEc2query_deserializeOpCreatePublicIpv4Pool) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreatePublicIpv4Pool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11024,14 +10929,14 @@ func awsEc2query_deserializeOpErrorCreatePublicIpv4Pool(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreateReplaceRootVolumeTask struct {
+type awsEc2query_deserializeOpCreateNetworkInterfacePermission struct {
}
-func (*awsEc2query_deserializeOpCreateReplaceRootVolumeTask) ID() string {
+func (*awsEc2query_deserializeOpCreateNetworkInterfacePermission) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateReplaceRootVolumeTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateNetworkInterfacePermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11049,9 +10954,9 @@ func (m *awsEc2query_deserializeOpCreateReplaceRootVolumeTask) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateReplaceRootVolumeTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateNetworkInterfacePermission(response, &metadata)
}
- output := &CreateReplaceRootVolumeTaskOutput{}
+ output := &CreateNetworkInterfacePermissionOutput{}
out.Result = output
var buff [1024]byte
@@ -11072,7 +10977,7 @@ func (m *awsEc2query_deserializeOpCreateReplaceRootVolumeTask) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateReplaceRootVolumeTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateNetworkInterfacePermissionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11086,7 +10991,7 @@ func (m *awsEc2query_deserializeOpCreateReplaceRootVolumeTask) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateReplaceRootVolumeTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateNetworkInterfacePermission(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11119,14 +11024,14 @@ func awsEc2query_deserializeOpErrorCreateReplaceRootVolumeTask(response *smithyh
}
}
-type awsEc2query_deserializeOpCreateReservedInstancesListing struct {
+type awsEc2query_deserializeOpCreatePlacementGroup struct {
}
-func (*awsEc2query_deserializeOpCreateReservedInstancesListing) ID() string {
+func (*awsEc2query_deserializeOpCreatePlacementGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateReservedInstancesListing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreatePlacementGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11144,9 +11049,9 @@ func (m *awsEc2query_deserializeOpCreateReservedInstancesListing) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateReservedInstancesListing(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreatePlacementGroup(response, &metadata)
}
- output := &CreateReservedInstancesListingOutput{}
+ output := &CreatePlacementGroupOutput{}
out.Result = output
var buff [1024]byte
@@ -11167,7 +11072,7 @@ func (m *awsEc2query_deserializeOpCreateReservedInstancesListing) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateReservedInstancesListingOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreatePlacementGroupOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11181,7 +11086,7 @@ func (m *awsEc2query_deserializeOpCreateReservedInstancesListing) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateReservedInstancesListing(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreatePlacementGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11214,14 +11119,14 @@ func awsEc2query_deserializeOpErrorCreateReservedInstancesListing(response *smit
}
}
-type awsEc2query_deserializeOpCreateRestoreImageTask struct {
+type awsEc2query_deserializeOpCreatePublicIpv4Pool struct {
}
-func (*awsEc2query_deserializeOpCreateRestoreImageTask) ID() string {
+func (*awsEc2query_deserializeOpCreatePublicIpv4Pool) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateRestoreImageTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreatePublicIpv4Pool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11239,9 +11144,9 @@ func (m *awsEc2query_deserializeOpCreateRestoreImageTask) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateRestoreImageTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreatePublicIpv4Pool(response, &metadata)
}
- output := &CreateRestoreImageTaskOutput{}
+ output := &CreatePublicIpv4PoolOutput{}
out.Result = output
var buff [1024]byte
@@ -11262,7 +11167,7 @@ func (m *awsEc2query_deserializeOpCreateRestoreImageTask) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateRestoreImageTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreatePublicIpv4PoolOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11276,7 +11181,7 @@ func (m *awsEc2query_deserializeOpCreateRestoreImageTask) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateRestoreImageTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreatePublicIpv4Pool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11309,14 +11214,14 @@ func awsEc2query_deserializeOpErrorCreateRestoreImageTask(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpCreateRoute struct {
+type awsEc2query_deserializeOpCreateReplaceRootVolumeTask struct {
}
-func (*awsEc2query_deserializeOpCreateRoute) ID() string {
+func (*awsEc2query_deserializeOpCreateReplaceRootVolumeTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateReplaceRootVolumeTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11334,9 +11239,9 @@ func (m *awsEc2query_deserializeOpCreateRoute) HandleDeserialize(ctx context.Con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateReplaceRootVolumeTask(response, &metadata)
}
- output := &CreateRouteOutput{}
+ output := &CreateReplaceRootVolumeTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -11357,7 +11262,7 @@ func (m *awsEc2query_deserializeOpCreateRoute) HandleDeserialize(ctx context.Con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateReplaceRootVolumeTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11371,7 +11276,7 @@ func (m *awsEc2query_deserializeOpCreateRoute) HandleDeserialize(ctx context.Con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateReplaceRootVolumeTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11404,14 +11309,14 @@ func awsEc2query_deserializeOpErrorCreateRoute(response *smithyhttp.Response, me
}
}
-type awsEc2query_deserializeOpCreateRouteServer struct {
+type awsEc2query_deserializeOpCreateReservedInstancesListing struct {
}
-func (*awsEc2query_deserializeOpCreateRouteServer) ID() string {
+func (*awsEc2query_deserializeOpCreateReservedInstancesListing) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateReservedInstancesListing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11429,9 +11334,9 @@ func (m *awsEc2query_deserializeOpCreateRouteServer) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateRouteServer(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateReservedInstancesListing(response, &metadata)
}
- output := &CreateRouteServerOutput{}
+ output := &CreateReservedInstancesListingOutput{}
out.Result = output
var buff [1024]byte
@@ -11452,7 +11357,7 @@ func (m *awsEc2query_deserializeOpCreateRouteServer) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateRouteServerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateReservedInstancesListingOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11466,7 +11371,7 @@ func (m *awsEc2query_deserializeOpCreateRouteServer) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateReservedInstancesListing(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11499,14 +11404,14 @@ func awsEc2query_deserializeOpErrorCreateRouteServer(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpCreateRouteServerEndpoint struct {
+type awsEc2query_deserializeOpCreateRestoreImageTask struct {
}
-func (*awsEc2query_deserializeOpCreateRouteServerEndpoint) ID() string {
+func (*awsEc2query_deserializeOpCreateRestoreImageTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateRouteServerEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateRestoreImageTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11524,9 +11429,9 @@ func (m *awsEc2query_deserializeOpCreateRouteServerEndpoint) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateRouteServerEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateRestoreImageTask(response, &metadata)
}
- output := &CreateRouteServerEndpointOutput{}
+ output := &CreateRestoreImageTaskOutput{}
out.Result = output
var buff [1024]byte
@@ -11547,7 +11452,7 @@ func (m *awsEc2query_deserializeOpCreateRouteServerEndpoint) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateRouteServerEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateRestoreImageTaskOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11561,7 +11466,7 @@ func (m *awsEc2query_deserializeOpCreateRouteServerEndpoint) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateRouteServerEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateRestoreImageTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11594,14 +11499,14 @@ func awsEc2query_deserializeOpErrorCreateRouteServerEndpoint(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateRouteServerPeer struct {
+type awsEc2query_deserializeOpCreateRoute struct {
}
-func (*awsEc2query_deserializeOpCreateRouteServerPeer) ID() string {
+func (*awsEc2query_deserializeOpCreateRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateRouteServerPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11619,9 +11524,9 @@ func (m *awsEc2query_deserializeOpCreateRouteServerPeer) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateRouteServerPeer(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateRoute(response, &metadata)
}
- output := &CreateRouteServerPeerOutput{}
+ output := &CreateRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -11642,7 +11547,7 @@ func (m *awsEc2query_deserializeOpCreateRouteServerPeer) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateRouteServerPeerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11656,7 +11561,7 @@ func (m *awsEc2query_deserializeOpCreateRouteServerPeer) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateRouteServerPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11689,14 +11594,14 @@ func awsEc2query_deserializeOpErrorCreateRouteServerPeer(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpCreateRouteTable struct {
+type awsEc2query_deserializeOpCreateRouteServer struct {
}
-func (*awsEc2query_deserializeOpCreateRouteTable) ID() string {
+func (*awsEc2query_deserializeOpCreateRouteServer) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11714,9 +11619,9 @@ func (m *awsEc2query_deserializeOpCreateRouteTable) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateRouteTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateRouteServer(response, &metadata)
}
- output := &CreateRouteTableOutput{}
+ output := &CreateRouteServerOutput{}
out.Result = output
var buff [1024]byte
@@ -11737,7 +11642,7 @@ func (m *awsEc2query_deserializeOpCreateRouteTable) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateRouteTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateRouteServerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11751,7 +11656,7 @@ func (m *awsEc2query_deserializeOpCreateRouteTable) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11784,14 +11689,14 @@ func awsEc2query_deserializeOpErrorCreateRouteTable(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpCreateSecondaryNetwork struct {
+type awsEc2query_deserializeOpCreateRouteServerEndpoint struct {
}
-func (*awsEc2query_deserializeOpCreateSecondaryNetwork) ID() string {
+func (*awsEc2query_deserializeOpCreateRouteServerEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSecondaryNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateRouteServerEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11809,9 +11714,9 @@ func (m *awsEc2query_deserializeOpCreateSecondaryNetwork) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateRouteServerEndpoint(response, &metadata)
}
- output := &CreateSecondaryNetworkOutput{}
+ output := &CreateRouteServerEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -11832,7 +11737,7 @@ func (m *awsEc2query_deserializeOpCreateSecondaryNetwork) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSecondaryNetworkOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateRouteServerEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11846,7 +11751,7 @@ func (m *awsEc2query_deserializeOpCreateSecondaryNetwork) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateRouteServerEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11879,14 +11784,14 @@ func awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpCreateSecondarySubnet struct {
+type awsEc2query_deserializeOpCreateRouteServerPeer struct {
}
-func (*awsEc2query_deserializeOpCreateSecondarySubnet) ID() string {
+func (*awsEc2query_deserializeOpCreateRouteServerPeer) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSecondarySubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateRouteServerPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11904,9 +11809,9 @@ func (m *awsEc2query_deserializeOpCreateSecondarySubnet) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSecondarySubnet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateRouteServerPeer(response, &metadata)
}
- output := &CreateSecondarySubnetOutput{}
+ output := &CreateRouteServerPeerOutput{}
out.Result = output
var buff [1024]byte
@@ -11927,7 +11832,7 @@ func (m *awsEc2query_deserializeOpCreateSecondarySubnet) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSecondarySubnetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateRouteServerPeerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -11941,7 +11846,7 @@ func (m *awsEc2query_deserializeOpCreateSecondarySubnet) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSecondarySubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateRouteServerPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -11974,14 +11879,14 @@ func awsEc2query_deserializeOpErrorCreateSecondarySubnet(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpCreateSecurityGroup struct {
+type awsEc2query_deserializeOpCreateRouteTable struct {
}
-func (*awsEc2query_deserializeOpCreateSecurityGroup) ID() string {
+func (*awsEc2query_deserializeOpCreateRouteTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -11999,9 +11904,9 @@ func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSecurityGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateRouteTable(response, &metadata)
}
- output := &CreateSecurityGroupOutput{}
+ output := &CreateRouteTableOutput{}
out.Result = output
var buff [1024]byte
@@ -12022,7 +11927,7 @@ func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSecurityGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateRouteTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12036,7 +11941,7 @@ func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12069,14 +11974,14 @@ func awsEc2query_deserializeOpErrorCreateSecurityGroup(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpCreateSnapshot struct {
+type awsEc2query_deserializeOpCreateSecondaryNetwork struct {
}
-func (*awsEc2query_deserializeOpCreateSnapshot) ID() string {
+func (*awsEc2query_deserializeOpCreateSecondaryNetwork) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSecondaryNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12094,9 +11999,9 @@ func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshot(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response, &metadata)
}
- output := &CreateSnapshotOutput{}
+ output := &CreateSecondaryNetworkOutput{}
out.Result = output
var buff [1024]byte
@@ -12117,7 +12022,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSnapshotOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSecondaryNetworkOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12131,7 +12036,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSecondaryNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12164,14 +12069,14 @@ func awsEc2query_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpCreateSnapshots struct {
+type awsEc2query_deserializeOpCreateSecondarySubnet struct {
}
-func (*awsEc2query_deserializeOpCreateSnapshots) ID() string {
+func (*awsEc2query_deserializeOpCreateSecondarySubnet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSecondarySubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12189,9 +12094,9 @@ func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshots(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSecondarySubnet(response, &metadata)
}
- output := &CreateSnapshotsOutput{}
+ output := &CreateSecondarySubnetOutput{}
out.Result = output
var buff [1024]byte
@@ -12212,7 +12117,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSnapshotsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSecondarySubnetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12226,7 +12131,7 @@ func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSecondarySubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12259,14 +12164,14 @@ func awsEc2query_deserializeOpErrorCreateSnapshots(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpCreateSpotDatafeedSubscription struct {
+type awsEc2query_deserializeOpCreateSecurityGroup struct {
}
-func (*awsEc2query_deserializeOpCreateSpotDatafeedSubscription) ID() string {
+func (*awsEc2query_deserializeOpCreateSecurityGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSecurityGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12284,9 +12189,9 @@ func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSecurityGroup(response, &metadata)
}
- output := &CreateSpotDatafeedSubscriptionOutput{}
+ output := &CreateSecurityGroupOutput{}
out.Result = output
var buff [1024]byte
@@ -12307,7 +12212,7 @@ func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSpotDatafeedSubscriptionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSecurityGroupOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12321,7 +12226,7 @@ func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSecurityGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12354,14 +12259,14 @@ func awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response *smit
}
}
-type awsEc2query_deserializeOpCreateStoreImageTask struct {
+type awsEc2query_deserializeOpCreateSnapshot struct {
}
-func (*awsEc2query_deserializeOpCreateStoreImageTask) ID() string {
+func (*awsEc2query_deserializeOpCreateSnapshot) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12379,9 +12284,9 @@ func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateStoreImageTask(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshot(response, &metadata)
}
- output := &CreateStoreImageTaskOutput{}
+ output := &CreateSnapshotOutput{}
out.Result = output
var buff [1024]byte
@@ -12402,7 +12307,7 @@ func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateStoreImageTaskOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSnapshotOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12416,7 +12321,7 @@ func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateStoreImageTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12449,14 +12354,14 @@ func awsEc2query_deserializeOpErrorCreateStoreImageTask(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreateSubnet struct {
+type awsEc2query_deserializeOpCreateSnapshots struct {
}
-func (*awsEc2query_deserializeOpCreateSubnet) ID() string {
+func (*awsEc2query_deserializeOpCreateSnapshots) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12474,9 +12379,9 @@ func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSubnet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSnapshots(response, &metadata)
}
- output := &CreateSubnetOutput{}
+ output := &CreateSnapshotsOutput{}
out.Result = output
var buff [1024]byte
@@ -12497,7 +12402,7 @@ func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSubnetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSnapshotsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12511,7 +12416,7 @@ func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12544,14 +12449,14 @@ func awsEc2query_deserializeOpErrorCreateSubnet(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpCreateSubnetCidrReservation struct {
+type awsEc2query_deserializeOpCreateSpotDatafeedSubscription struct {
}
-func (*awsEc2query_deserializeOpCreateSubnetCidrReservation) ID() string {
+func (*awsEc2query_deserializeOpCreateSpotDatafeedSubscription) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12569,9 +12474,9 @@ func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response, &metadata)
}
- output := &CreateSubnetCidrReservationOutput{}
+ output := &CreateSpotDatafeedSubscriptionOutput{}
out.Result = output
var buff [1024]byte
@@ -12592,7 +12497,7 @@ func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateSubnetCidrReservationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSpotDatafeedSubscriptionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12606,7 +12511,7 @@ func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12639,14 +12544,14 @@ func awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response *smithyh
}
}
-type awsEc2query_deserializeOpCreateTags struct {
+type awsEc2query_deserializeOpCreateStoreImageTask struct {
}
-func (*awsEc2query_deserializeOpCreateTags) ID() string {
+func (*awsEc2query_deserializeOpCreateStoreImageTask) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateStoreImageTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12664,21 +12569,44 @@ func (m *awsEc2query_deserializeOpCreateTags) HandleDeserialize(ctx context.Cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTags(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateStoreImageTask(response, &metadata)
}
- output := &CreateTagsOutput{}
+ output := &CreateStoreImageTaskOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentCreateStoreImageTaskOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateStoreImageTask(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12711,14 +12639,14 @@ func awsEc2query_deserializeOpErrorCreateTags(response *smithyhttp.Response, met
}
}
-type awsEc2query_deserializeOpCreateTrafficMirrorFilter struct {
+type awsEc2query_deserializeOpCreateSubnet struct {
}
-func (*awsEc2query_deserializeOpCreateTrafficMirrorFilter) ID() string {
+func (*awsEc2query_deserializeOpCreateSubnet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSubnet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12736,9 +12664,9 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSubnet(response, &metadata)
}
- output := &CreateTrafficMirrorFilterOutput{}
+ output := &CreateSubnetOutput{}
out.Result = output
var buff [1024]byte
@@ -12759,7 +12687,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSubnetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12773,7 +12701,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSubnet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12806,14 +12734,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateTrafficMirrorFilterRule struct {
+type awsEc2query_deserializeOpCreateSubnetCidrReservation struct {
}
-func (*awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) ID() string {
+func (*awsEc2query_deserializeOpCreateSubnetCidrReservation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateSubnetCidrReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12831,9 +12759,9 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response, &metadata)
}
- output := &CreateTrafficMirrorFilterRuleOutput{}
+ output := &CreateSubnetCidrReservationOutput{}
out.Result = output
var buff [1024]byte
@@ -12854,7 +12782,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterRuleOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateSubnetCidrReservationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -12868,7 +12796,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateSubnetCidrReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12901,14 +12829,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response *smith
}
}
-type awsEc2query_deserializeOpCreateTrafficMirrorSession struct {
+type awsEc2query_deserializeOpCreateTags struct {
}
-func (*awsEc2query_deserializeOpCreateTrafficMirrorSession) ID() string {
+func (*awsEc2query_deserializeOpCreateTags) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -12926,44 +12854,21 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTags(response, &metadata)
}
- output := &CreateTrafficMirrorSessionOutput{}
+ output := &CreateTagsOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorSessionOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -12996,14 +12901,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response *smithyht
}
}
-type awsEc2query_deserializeOpCreateTrafficMirrorTarget struct {
+type awsEc2query_deserializeOpCreateTrafficMirrorFilter struct {
}
-func (*awsEc2query_deserializeOpCreateTrafficMirrorTarget) ID() string {
+func (*awsEc2query_deserializeOpCreateTrafficMirrorFilter) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilter) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13021,9 +12926,9 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response, &metadata)
}
- output := &CreateTrafficMirrorTargetOutput{}
+ output := &CreateTrafficMirrorFilterOutput{}
out.Result = output
var buff [1024]byte
@@ -13044,7 +12949,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorTargetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13058,7 +12963,7 @@ func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilter(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13091,14 +12996,14 @@ func awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateTransitGateway struct {
+type awsEc2query_deserializeOpCreateTrafficMirrorFilterRule struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13116,9 +13021,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response, &metadata)
}
- output := &CreateTransitGatewayOutput{}
+ output := &CreateTrafficMirrorFilterRuleOutput{}
out.Result = output
var buff [1024]byte
@@ -13139,7 +13044,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorFilterRuleOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13153,7 +13058,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13186,14 +13091,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGateway(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayConnect struct {
+type awsEc2query_deserializeOpCreateTrafficMirrorSession struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayConnect) ID() string {
+func (*awsEc2query_deserializeOpCreateTrafficMirrorSession) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13211,9 +13116,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response, &metadata)
}
- output := &CreateTransitGatewayConnectOutput{}
+ output := &CreateTrafficMirrorSessionOutput{}
out.Result = output
var buff [1024]byte
@@ -13234,7 +13139,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorSessionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13248,7 +13153,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13281,14 +13186,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response *smithyh
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayConnectPeer struct {
+type awsEc2query_deserializeOpCreateTrafficMirrorTarget struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) ID() string {
+func (*awsEc2query_deserializeOpCreateTrafficMirrorTarget) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTrafficMirrorTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13306,9 +13211,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response, &metadata)
}
- output := &CreateTransitGatewayConnectPeerOutput{}
+ output := &CreateTrafficMirrorTargetOutput{}
out.Result = output
var buff [1024]byte
@@ -13329,7 +13234,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectPeerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTrafficMirrorTargetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13343,7 +13248,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTrafficMirrorTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13376,14 +13281,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response *smi
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy struct {
+type awsEc2query_deserializeOpCreateTransitGateway struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13401,9 +13306,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGateway(response, &metadata)
}
- output := &CreateTransitGatewayMeteringPolicyOutput{}
+ output := &CreateTransitGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -13424,7 +13329,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13438,7 +13343,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13471,14 +13376,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response *
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry struct {
+type awsEc2query_deserializeOpCreateTransitGatewayConnect struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayConnect) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayConnect) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13496,9 +13401,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response, &metadata)
}
- output := &CreateTransitGatewayMeteringPolicyEntryOutput{}
+ output := &CreateTransitGatewayConnectOutput{}
out.Result = output
var buff [1024]byte
@@ -13519,7 +13424,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyEntryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13533,7 +13438,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayConnect(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13566,14 +13471,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(respo
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain struct {
+type awsEc2query_deserializeOpCreateTransitGatewayConnectPeer struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayConnectPeer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13591,9 +13496,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response, &metadata)
}
- output := &CreateTransitGatewayMulticastDomainOutput{}
+ output := &CreateTransitGatewayConnectPeerOutput{}
out.Result = output
var buff [1024]byte
@@ -13614,7 +13519,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMulticastDomainOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayConnectPeerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13628,7 +13533,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayConnectPeer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13661,14 +13566,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment struct {
+type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13686,9 +13591,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response, &metadata)
}
- output := &CreateTransitGatewayPeeringAttachmentOutput{}
+ output := &CreateTransitGatewayMeteringPolicyOutput{}
out.Result = output
var buff [1024]byte
@@ -13709,7 +13614,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPeeringAttachmentOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13723,7 +13628,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13756,14 +13661,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(respons
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayPolicyTable struct {
+type awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayMeteringPolicyEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13781,9 +13686,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response, &metadata)
}
- output := &CreateTransitGatewayPolicyTableOutput{}
+ output := &CreateTransitGatewayMeteringPolicyEntryOutput{}
out.Result = output
var buff [1024]byte
@@ -13804,7 +13709,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPolicyTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMeteringPolicyEntryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13818,7 +13723,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayMeteringPolicyEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13851,14 +13756,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response *smi
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry struct {
+type awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayMulticastDomain) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13876,9 +13781,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTableEntry(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response, &metadata)
}
- output := &CreateTransitGatewayPolicyTableEntryOutput{}
+ output := &CreateTransitGatewayMulticastDomainOutput{}
out.Result = output
var buff [1024]byte
@@ -13899,7 +13804,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPolicyTableEntryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayMulticastDomainOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -13913,7 +13818,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTableEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayMulticastDomain(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -13946,14 +13851,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTableEntry(response
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference struct {
+type awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -13971,9 +13876,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response, &metadata)
}
- output := &CreateTransitGatewayPrefixListReferenceOutput{}
+ output := &CreateTransitGatewayPeeringAttachmentOutput{}
out.Result = output
var buff [1024]byte
@@ -13994,7 +13899,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPrefixListReferenceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPeeringAttachmentOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14008,7 +13913,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14041,14 +13946,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(respo
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayRoute struct {
+type awsEc2query_deserializeOpCreateTransitGatewayPolicyTable struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayRoute) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14066,9 +13971,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response, &metadata)
}
- output := &CreateTransitGatewayRouteOutput{}
+ output := &CreateTransitGatewayPolicyTableOutput{}
out.Result = output
var buff [1024]byte
@@ -14089,7 +13994,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPolicyTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14103,7 +14008,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14136,14 +14041,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayRouteTable struct {
+type awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTable) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayPolicyTableEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14161,9 +14066,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTableEntry(response, &metadata)
}
- output := &CreateTransitGatewayRouteTableOutput{}
+ output := &CreateTransitGatewayPolicyTableEntryOutput{}
out.Result = output
var buff [1024]byte
@@ -14184,7 +14089,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPolicyTableEntryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14198,7 +14103,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayPolicyTableEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14231,14 +14136,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response *smit
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement struct {
+type awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14256,9 +14161,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response, &metadata)
}
- output := &CreateTransitGatewayRouteTableAnnouncementOutput{}
+ output := &CreateTransitGatewayPrefixListReferenceOutput{}
out.Result = output
var buff [1024]byte
@@ -14279,7 +14184,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableAnnouncementOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayPrefixListReferenceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14293,7 +14198,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14326,14 +14231,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(re
}
}
-type awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment struct {
+type awsEc2query_deserializeOpCreateTransitGatewayRoute struct {
}
-func (*awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14351,9 +14256,9 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response, &metadata)
}
- output := &CreateTransitGatewayVpcAttachmentOutput{}
+ output := &CreateTransitGatewayRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -14374,7 +14279,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateTransitGatewayVpcAttachmentOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14388,7 +14293,7 @@ func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14421,14 +14326,14 @@ func awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response *s
}
}
-type awsEc2query_deserializeOpCreateVerifiedAccessEndpoint struct {
+type awsEc2query_deserializeOpCreateTransitGatewayRouteTable struct {
}
-func (*awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14446,9 +14351,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response, &metadata)
}
- output := &CreateVerifiedAccessEndpointOutput{}
+ output := &CreateTransitGatewayRouteTableOutput{}
out.Result = output
var buff [1024]byte
@@ -14469,7 +14374,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14483,7 +14388,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14516,14 +14421,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response *smithy
}
}
-type awsEc2query_deserializeOpCreateVerifiedAccessGroup struct {
+type awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement struct {
}
-func (*awsEc2query_deserializeOpCreateVerifiedAccessGroup) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayRouteTableAnnouncement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14541,9 +14446,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response, &metadata)
}
- output := &CreateVerifiedAccessGroupOutput{}
+ output := &CreateTransitGatewayRouteTableAnnouncementOutput{}
out.Result = output
var buff [1024]byte
@@ -14564,7 +14469,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayRouteTableAnnouncementOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14578,7 +14483,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayRouteTableAnnouncement(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14611,14 +14516,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response *smithyhtt
}
}
-type awsEc2query_deserializeOpCreateVerifiedAccessInstance struct {
+type awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment struct {
}
-func (*awsEc2query_deserializeOpCreateVerifiedAccessInstance) ID() string {
+func (*awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14636,9 +14541,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response, &metadata)
}
- output := &CreateVerifiedAccessInstanceOutput{}
+ output := &CreateTransitGatewayVpcAttachmentOutput{}
out.Result = output
var buff [1024]byte
@@ -14659,7 +14564,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessInstanceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateTransitGatewayVpcAttachmentOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14673,7 +14578,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14706,14 +14611,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response *smithy
}
}
-type awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider struct {
+type awsEc2query_deserializeOpCreateVerifiedAccessEndpoint struct {
}
-func (*awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) ID() string {
+func (*awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14731,9 +14636,9 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response, &metadata)
}
- output := &CreateVerifiedAccessTrustProviderOutput{}
+ output := &CreateVerifiedAccessEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -14754,7 +14659,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessTrustProviderOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14768,7 +14673,7 @@ func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14801,14 +14706,14 @@ func awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response *s
}
}
-type awsEc2query_deserializeOpCreateVolume struct {
+type awsEc2query_deserializeOpCreateVerifiedAccessGroup struct {
}
-func (*awsEc2query_deserializeOpCreateVolume) ID() string {
+func (*awsEc2query_deserializeOpCreateVerifiedAccessGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14826,9 +14731,9 @@ func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVolume(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response, &metadata)
}
- output := &CreateVolumeOutput{}
+ output := &CreateVerifiedAccessGroupOutput{}
out.Result = output
var buff [1024]byte
@@ -14849,7 +14754,7 @@ func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVolumeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessGroupOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14863,7 +14768,7 @@ func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14896,14 +14801,14 @@ func awsEc2query_deserializeOpErrorCreateVolume(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpCreateVpc struct {
+type awsEc2query_deserializeOpCreateVerifiedAccessInstance struct {
}
-func (*awsEc2query_deserializeOpCreateVpc) ID() string {
+func (*awsEc2query_deserializeOpCreateVerifiedAccessInstance) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -14921,9 +14826,9 @@ func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpc(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response, &metadata)
}
- output := &CreateVpcOutput{}
+ output := &CreateVerifiedAccessInstanceOutput{}
out.Result = output
var buff [1024]byte
@@ -14944,7 +14849,7 @@ func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessInstanceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -14958,7 +14863,7 @@ func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -14991,14 +14896,14 @@ func awsEc2query_deserializeOpErrorCreateVpc(response *smithyhttp.Response, meta
}
}
-type awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion struct {
+type awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider struct {
}
-func (*awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) ID() string {
+func (*awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15016,9 +14921,9 @@ func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response, &metadata)
}
- output := &CreateVpcBlockPublicAccessExclusionOutput{}
+ output := &CreateVerifiedAccessTrustProviderOutput{}
out.Result = output
var buff [1024]byte
@@ -15039,7 +14944,7 @@ func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcBlockPublicAccessExclusionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVerifiedAccessTrustProviderOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15053,7 +14958,7 @@ func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15086,14 +14991,14 @@ func awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response
}
}
-type awsEc2query_deserializeOpCreateVpcEncryptionControl struct {
+type awsEc2query_deserializeOpCreateVolume struct {
}
-func (*awsEc2query_deserializeOpCreateVpcEncryptionControl) ID() string {
+func (*awsEc2query_deserializeOpCreateVolume) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15111,9 +15016,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVolume(response, &metadata)
}
- output := &CreateVpcEncryptionControlOutput{}
+ output := &CreateVolumeOutput{}
out.Result = output
var buff [1024]byte
@@ -15134,7 +15039,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcEncryptionControlOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVolumeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15148,7 +15053,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15181,14 +15086,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response *smithyht
}
}
-type awsEc2query_deserializeOpCreateVpcEndpoint struct {
+type awsEc2query_deserializeOpCreateVpc struct {
}
-func (*awsEc2query_deserializeOpCreateVpcEndpoint) ID() string {
+func (*awsEc2query_deserializeOpCreateVpc) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15206,9 +15111,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpc(response, &metadata)
}
- output := &CreateVpcEndpointOutput{}
+ output := &CreateVpcOutput{}
out.Result = output
var buff [1024]byte
@@ -15229,7 +15134,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpcOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15243,7 +15148,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15276,14 +15181,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEndpoint(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification struct {
+type awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion struct {
}
-func (*awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) ID() string {
+func (*awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpcBlockPublicAccessExclusion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15301,9 +15206,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response, &metadata)
}
- output := &CreateVpcEndpointConnectionNotificationOutput{}
+ output := &CreateVpcBlockPublicAccessExclusionOutput{}
out.Result = output
var buff [1024]byte
@@ -15324,7 +15229,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcEndpointConnectionNotificationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpcBlockPublicAccessExclusionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15338,7 +15243,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpcBlockPublicAccessExclusion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15371,14 +15276,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(respo
}
}
-type awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration struct {
+type awsEc2query_deserializeOpCreateVpcEncryptionControl struct {
}
-func (*awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) ID() string {
+func (*awsEc2query_deserializeOpCreateVpcEncryptionControl) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpcEncryptionControl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15396,9 +15301,9 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response, &metadata)
}
- output := &CreateVpcEndpointServiceConfigurationOutput{}
+ output := &CreateVpcEncryptionControlOutput{}
out.Result = output
var buff [1024]byte
@@ -15419,7 +15324,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcEndpointServiceConfigurationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpcEncryptionControlOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15433,7 +15338,7 @@ func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpcEncryptionControl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15466,14 +15371,14 @@ func awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(respons
}
}
-type awsEc2query_deserializeOpCreateVpcPeeringConnection struct {
+type awsEc2query_deserializeOpCreateVpcEndpoint struct {
}
-func (*awsEc2query_deserializeOpCreateVpcPeeringConnection) ID() string {
+func (*awsEc2query_deserializeOpCreateVpcEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15491,9 +15396,9 @@ func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpoint(response, &metadata)
}
- output := &CreateVpcPeeringConnectionOutput{}
+ output := &CreateVpcEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -15514,7 +15419,7 @@ func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpcPeeringConnectionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpcEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15528,7 +15433,7 @@ func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15561,14 +15466,14 @@ func awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response *smithyht
}
}
-type awsEc2query_deserializeOpCreateVpnConcentrator struct {
+type awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification struct {
}
-func (*awsEc2query_deserializeOpCreateVpnConcentrator) ID() string {
+func (*awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15586,9 +15491,9 @@ func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConcentrator(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response, &metadata)
}
- output := &CreateVpnConcentratorOutput{}
+ output := &CreateVpcEndpointConnectionNotificationOutput{}
out.Result = output
var buff [1024]byte
@@ -15609,7 +15514,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpnConcentratorOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpcEndpointConnectionNotificationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15623,7 +15528,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpnConcentrator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15656,14 +15561,14 @@ func awsEc2query_deserializeOpErrorCreateVpnConcentrator(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpCreateVpnConnection struct {
+type awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration struct {
}
-func (*awsEc2query_deserializeOpCreateVpnConnection) ID() string {
+func (*awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15681,9 +15586,9 @@ func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnection(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response, &metadata)
}
- output := &CreateVpnConnectionOutput{}
+ output := &CreateVpcEndpointServiceConfigurationOutput{}
out.Result = output
var buff [1024]byte
@@ -15704,7 +15609,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpnConnectionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpcEndpointServiceConfigurationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15718,7 +15623,7 @@ func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15751,14 +15656,14 @@ func awsEc2query_deserializeOpErrorCreateVpnConnection(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpCreateVpnConnectionRoute struct {
+type awsEc2query_deserializeOpCreateVpcPeeringConnection struct {
}
-func (*awsEc2query_deserializeOpCreateVpnConnectionRoute) ID() string {
+func (*awsEc2query_deserializeOpCreateVpcPeeringConnection) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpnConnectionRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15776,21 +15681,44 @@ func (m *awsEc2query_deserializeOpCreateVpnConnectionRoute) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response, &metadata)
}
- output := &CreateVpnConnectionRouteOutput{}
+ output := &CreateVpcPeeringConnectionOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentCreateVpcPeeringConnectionOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15823,14 +15751,14 @@ func awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response *smithyhttp
}
}
-type awsEc2query_deserializeOpCreateVpnGateway struct {
+type awsEc2query_deserializeOpCreateVpnConcentrator struct {
}
-func (*awsEc2query_deserializeOpCreateVpnGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateVpnConcentrator) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpnConcentrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15848,9 +15776,9 @@ func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorCreateVpnGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConcentrator(response, &metadata)
}
- output := &CreateVpnGatewayOutput{}
+ output := &CreateVpnConcentratorOutput{}
out.Result = output
var buff [1024]byte
@@ -15871,7 +15799,7 @@ func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentCreateVpnGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpnConcentratorOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15885,7 +15813,7 @@ func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorCreateVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpnConcentrator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -15918,14 +15846,14 @@ func awsEc2query_deserializeOpErrorCreateVpnGateway(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDeleteCapacityManagerDataExport struct {
+type awsEc2query_deserializeOpCreateVpnConnection struct {
}
-func (*awsEc2query_deserializeOpDeleteCapacityManagerDataExport) ID() string {
+func (*awsEc2query_deserializeOpCreateVpnConnection) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -15943,9 +15871,9 @@ func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnection(response, &metadata)
}
- output := &DeleteCapacityManagerDataExportOutput{}
+ output := &CreateVpnConnectionOutput{}
out.Result = output
var buff [1024]byte
@@ -15966,7 +15894,7 @@ func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteCapacityManagerDataExportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpnConnectionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -15980,7 +15908,7 @@ func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16013,14 +15941,14 @@ func awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response *smi
}
}
-type awsEc2query_deserializeOpDeleteCarrierGateway struct {
+type awsEc2query_deserializeOpCreateVpnConnectionRoute struct {
}
-func (*awsEc2query_deserializeOpDeleteCarrierGateway) ID() string {
+func (*awsEc2query_deserializeOpCreateVpnConnectionRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpnConnectionRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16038,44 +15966,21 @@ func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteCarrierGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response, &metadata)
}
- output := &DeleteCarrierGatewayOutput{}
+ output := &CreateVpnConnectionRouteOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteCarrierGatewayOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteCarrierGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpnConnectionRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16108,14 +16013,14 @@ func awsEc2query_deserializeOpErrorDeleteCarrierGateway(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDeleteClientVpnEndpoint struct {
+type awsEc2query_deserializeOpCreateVpnGateway struct {
}
-func (*awsEc2query_deserializeOpDeleteClientVpnEndpoint) ID() string {
+func (*awsEc2query_deserializeOpCreateVpnGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpCreateVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16133,9 +16038,9 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorCreateVpnGateway(response, &metadata)
}
- output := &DeleteClientVpnEndpointOutput{}
+ output := &CreateVpnGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -16156,7 +16061,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteClientVpnEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentCreateVpnGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16170,7 +16075,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorCreateVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16203,14 +16108,14 @@ func awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDeleteClientVpnRoute struct {
+type awsEc2query_deserializeOpDeleteApplicationStatusCheck struct {
}
-func (*awsEc2query_deserializeOpDeleteClientVpnRoute) ID() string {
+func (*awsEc2query_deserializeOpDeleteApplicationStatusCheck) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteApplicationStatusCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16228,9 +16133,9 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteApplicationStatusCheck(response, &metadata)
}
- output := &DeleteClientVpnRouteOutput{}
+ output := &DeleteApplicationStatusCheckOutput{}
out.Result = output
var buff [1024]byte
@@ -16251,7 +16156,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteClientVpnRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteApplicationStatusCheckOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16265,7 +16170,7 @@ func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteApplicationStatusCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16298,14 +16203,14 @@ func awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDeleteCoipCidr struct {
+type awsEc2query_deserializeOpDeleteCapacityManagerDataExport struct {
}
-func (*awsEc2query_deserializeOpDeleteCoipCidr) ID() string {
+func (*awsEc2query_deserializeOpDeleteCapacityManagerDataExport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteCapacityManagerDataExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16323,9 +16228,9 @@ func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response, &metadata)
}
- output := &DeleteCoipCidrOutput{}
+ output := &DeleteCapacityManagerDataExportOutput{}
out.Result = output
var buff [1024]byte
@@ -16346,7 +16251,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteCoipCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteCapacityManagerDataExportOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16360,7 +16265,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteCoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteCapacityManagerDataExport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16393,14 +16298,14 @@ func awsEc2query_deserializeOpErrorDeleteCoipCidr(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDeleteCoipPool struct {
+type awsEc2query_deserializeOpDeleteCarrierGateway struct {
}
-func (*awsEc2query_deserializeOpDeleteCoipPool) ID() string {
+func (*awsEc2query_deserializeOpDeleteCarrierGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteCarrierGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16418,9 +16323,9 @@ func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipPool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteCarrierGateway(response, &metadata)
}
- output := &DeleteCoipPoolOutput{}
+ output := &DeleteCarrierGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -16441,7 +16346,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteCoipPoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteCarrierGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16455,7 +16360,7 @@ func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteCoipPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteCarrierGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16488,14 +16393,14 @@ func awsEc2query_deserializeOpErrorDeleteCoipPool(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDeleteCustomerGateway struct {
+type awsEc2query_deserializeOpDeleteClientVpnEndpoint struct {
}
-func (*awsEc2query_deserializeOpDeleteCustomerGateway) ID() string {
+func (*awsEc2query_deserializeOpDeleteClientVpnEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteCustomerGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16513,21 +16418,44 @@ func (m *awsEc2query_deserializeOpDeleteCustomerGateway) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteCustomerGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response, &metadata)
}
- output := &DeleteCustomerGatewayOutput{}
+ output := &DeleteClientVpnEndpointOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeleteClientVpnEndpointOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteCustomerGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16560,14 +16488,14 @@ func awsEc2query_deserializeOpErrorDeleteCustomerGateway(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpDeleteDhcpOptions struct {
+type awsEc2query_deserializeOpDeleteClientVpnRoute struct {
}
-func (*awsEc2query_deserializeOpDeleteDhcpOptions) ID() string {
+func (*awsEc2query_deserializeOpDeleteClientVpnRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteClientVpnRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16585,21 +16513,44 @@ func (m *awsEc2query_deserializeOpDeleteDhcpOptions) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteDhcpOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response, &metadata)
}
- output := &DeleteDhcpOptionsOutput{}
+ output := &DeleteClientVpnRouteOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeleteClientVpnRouteOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteClientVpnRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16632,14 +16583,14 @@ func awsEc2query_deserializeOpErrorDeleteDhcpOptions(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway struct {
+type awsEc2query_deserializeOpDeleteCoipCidr struct {
}
-func (*awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) ID() string {
+func (*awsEc2query_deserializeOpDeleteCoipCidr) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteCoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16657,9 +16608,9 @@ func (m *awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteEgressOnlyInternetGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipCidr(response, &metadata)
}
- output := &DeleteEgressOnlyInternetGatewayOutput{}
+ output := &DeleteCoipCidrOutput{}
out.Result = output
var buff [1024]byte
@@ -16680,7 +16631,7 @@ func (m *awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteEgressOnlyInternetGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteCoipCidrOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16694,7 +16645,7 @@ func (m *awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteEgressOnlyInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteCoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16727,14 +16678,14 @@ func awsEc2query_deserializeOpErrorDeleteEgressOnlyInternetGateway(response *smi
}
}
-type awsEc2query_deserializeOpDeleteFleets struct {
+type awsEc2query_deserializeOpDeleteCoipPool struct {
}
-func (*awsEc2query_deserializeOpDeleteFleets) ID() string {
+func (*awsEc2query_deserializeOpDeleteCoipPool) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteCoipPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16752,9 +16703,9 @@ func (m *awsEc2query_deserializeOpDeleteFleets) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteFleets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteCoipPool(response, &metadata)
}
- output := &DeleteFleetsOutput{}
+ output := &DeleteCoipPoolOutput{}
out.Result = output
var buff [1024]byte
@@ -16775,7 +16726,7 @@ func (m *awsEc2query_deserializeOpDeleteFleets) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteFleetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteCoipPoolOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16789,7 +16740,7 @@ func (m *awsEc2query_deserializeOpDeleteFleets) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteCoipPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16822,14 +16773,14 @@ func awsEc2query_deserializeOpErrorDeleteFleets(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpDeleteFlowLogs struct {
+type awsEc2query_deserializeOpDeleteCustomerGateway struct {
}
-func (*awsEc2query_deserializeOpDeleteFlowLogs) ID() string {
+func (*awsEc2query_deserializeOpDeleteCustomerGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteFlowLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteCustomerGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16847,44 +16798,93 @@ func (m *awsEc2query_deserializeOpDeleteFlowLogs) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteFlowLogs(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteCustomerGateway(response, &metadata)
}
- output := &DeleteFlowLogsOutput{}
+ output := &DeleteCustomerGatewayOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteFlowLogsOutput(&output, decoder)
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDeleteCustomerGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
}
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDeleteDhcpOptions struct {
+}
+
+func (*awsEc2query_deserializeOpDeleteDhcpOptions) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDeleteDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
return out, metadata, err
}
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteDhcpOptions(response, &metadata)
+ }
+ output := &DeleteDhcpOptionsOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteFlowLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -16917,14 +16917,14 @@ func awsEc2query_deserializeOpErrorDeleteFlowLogs(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDeleteFpgaImage struct {
+type awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway struct {
}
-func (*awsEc2query_deserializeOpDeleteFpgaImage) ID() string {
+func (*awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteFpgaImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteEgressOnlyInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -16942,9 +16942,9 @@ func (m *awsEc2query_deserializeOpDeleteFpgaImage) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteFpgaImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteEgressOnlyInternetGateway(response, &metadata)
}
- output := &DeleteFpgaImageOutput{}
+ output := &DeleteEgressOnlyInternetGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -16965,7 +16965,7 @@ func (m *awsEc2query_deserializeOpDeleteFpgaImage) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteFpgaImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteEgressOnlyInternetGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -16979,7 +16979,7 @@ func (m *awsEc2query_deserializeOpDeleteFpgaImage) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteFpgaImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteEgressOnlyInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17012,14 +17012,14 @@ func awsEc2query_deserializeOpErrorDeleteFpgaImage(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpDeleteImageUsageReport struct {
+type awsEc2query_deserializeOpDeleteFleets struct {
}
-func (*awsEc2query_deserializeOpDeleteImageUsageReport) ID() string {
+func (*awsEc2query_deserializeOpDeleteFleets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteImageUsageReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17037,9 +17037,9 @@ func (m *awsEc2query_deserializeOpDeleteImageUsageReport) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteImageUsageReport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteFleets(response, &metadata)
}
- output := &DeleteImageUsageReportOutput{}
+ output := &DeleteFleetsOutput{}
out.Result = output
var buff [1024]byte
@@ -17060,7 +17060,7 @@ func (m *awsEc2query_deserializeOpDeleteImageUsageReport) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteImageUsageReportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteFleetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17074,7 +17074,7 @@ func (m *awsEc2query_deserializeOpDeleteImageUsageReport) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteImageUsageReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17107,14 +17107,14 @@ func awsEc2query_deserializeOpErrorDeleteImageUsageReport(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDeleteInstanceConnectEndpoint struct {
+type awsEc2query_deserializeOpDeleteFlowLogs struct {
}
-func (*awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) ID() string {
+func (*awsEc2query_deserializeOpDeleteFlowLogs) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteFlowLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17132,9 +17132,9 @@ func (m *awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteInstanceConnectEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteFlowLogs(response, &metadata)
}
- output := &DeleteInstanceConnectEndpointOutput{}
+ output := &DeleteFlowLogsOutput{}
out.Result = output
var buff [1024]byte
@@ -17155,7 +17155,7 @@ func (m *awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteInstanceConnectEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteFlowLogsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17169,7 +17169,7 @@ func (m *awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteFlowLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17202,14 +17202,14 @@ func awsEc2query_deserializeOpErrorDeleteInstanceConnectEndpoint(response *smith
}
}
-type awsEc2query_deserializeOpDeleteInstanceEventWindow struct {
+type awsEc2query_deserializeOpDeleteFpgaImage struct {
}
-func (*awsEc2query_deserializeOpDeleteInstanceEventWindow) ID() string {
+func (*awsEc2query_deserializeOpDeleteFpgaImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteFpgaImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17227,9 +17227,9 @@ func (m *awsEc2query_deserializeOpDeleteInstanceEventWindow) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteInstanceEventWindow(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteFpgaImage(response, &metadata)
}
- output := &DeleteInstanceEventWindowOutput{}
+ output := &DeleteFpgaImageOutput{}
out.Result = output
var buff [1024]byte
@@ -17250,7 +17250,7 @@ func (m *awsEc2query_deserializeOpDeleteInstanceEventWindow) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteInstanceEventWindowOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteFpgaImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17264,7 +17264,7 @@ func (m *awsEc2query_deserializeOpDeleteInstanceEventWindow) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteFpgaImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17297,14 +17297,14 @@ func awsEc2query_deserializeOpErrorDeleteInstanceEventWindow(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDeleteInternetGateway struct {
+type awsEc2query_deserializeOpDeleteImageUsageReport struct {
}
-func (*awsEc2query_deserializeOpDeleteInternetGateway) ID() string {
+func (*awsEc2query_deserializeOpDeleteImageUsageReport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteImageUsageReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17322,21 +17322,44 @@ func (m *awsEc2query_deserializeOpDeleteInternetGateway) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteInternetGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteImageUsageReport(response, &metadata)
}
- output := &DeleteInternetGatewayOutput{}
+ output := &DeleteImageUsageReportOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeleteImageUsageReportOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteImageUsageReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17369,14 +17392,14 @@ func awsEc2query_deserializeOpErrorDeleteInternetGateway(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpDeleteIpam struct {
+type awsEc2query_deserializeOpDeleteInstanceConnectEndpoint struct {
}
-func (*awsEc2query_deserializeOpDeleteIpam) ID() string {
+func (*awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17394,9 +17417,9 @@ func (m *awsEc2query_deserializeOpDeleteIpam) HandleDeserialize(ctx context.Cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpam(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteInstanceConnectEndpoint(response, &metadata)
}
- output := &DeleteIpamOutput{}
+ output := &DeleteInstanceConnectEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -17417,7 +17440,7 @@ func (m *awsEc2query_deserializeOpDeleteIpam) HandleDeserialize(ctx context.Cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteInstanceConnectEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17431,7 +17454,7 @@ func (m *awsEc2query_deserializeOpDeleteIpam) HandleDeserialize(ctx context.Cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17464,14 +17487,14 @@ func awsEc2query_deserializeOpErrorDeleteIpam(response *smithyhttp.Response, met
}
}
-type awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken struct {
+type awsEc2query_deserializeOpDeleteInstanceEventWindow struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) ID() string {
+func (*awsEc2query_deserializeOpDeleteInstanceEventWindow) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17489,9 +17512,9 @@ func (m *awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamExternalResourceVerificationToken(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteInstanceEventWindow(response, &metadata)
}
- output := &DeleteIpamExternalResourceVerificationTokenOutput{}
+ output := &DeleteInstanceEventWindowOutput{}
out.Result = output
var buff [1024]byte
@@ -17512,7 +17535,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamExternalResourceVerificationTokenOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteInstanceEventWindowOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17526,7 +17549,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamExternalResourceVerificationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17559,14 +17582,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamExternalResourceVerificationToken(r
}
}
-type awsEc2query_deserializeOpDeleteIpamPolicy struct {
+type awsEc2query_deserializeOpDeleteInternetGateway struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamPolicy) ID() string {
+func (*awsEc2query_deserializeOpDeleteInternetGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17584,44 +17607,21 @@ func (m *awsEc2query_deserializeOpDeleteIpamPolicy) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPolicy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteInternetGateway(response, &metadata)
}
- output := &DeleteIpamPolicyOutput{}
+ output := &DeleteInternetGatewayOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamPolicyOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17654,14 +17654,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamPolicy(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDeleteIpamPool struct {
+type awsEc2query_deserializeOpDeleteIpam struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamPool) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpam) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17679,9 +17679,9 @@ func (m *awsEc2query_deserializeOpDeleteIpamPool) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpam(response, &metadata)
}
- output := &DeleteIpamPoolOutput{}
+ output := &DeleteIpamOutput{}
out.Result = output
var buff [1024]byte
@@ -17702,7 +17702,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamPool) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamPoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17716,7 +17716,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamPool) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17749,14 +17749,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamPool(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDeleteIpamPrefixListResolver struct {
+type awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamPrefixListResolver) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamExternalResourceVerificationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17774,9 +17774,9 @@ func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolver) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolver(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamExternalResourceVerificationToken(response, &metadata)
}
- output := &DeleteIpamPrefixListResolverOutput{}
+ output := &DeleteIpamExternalResourceVerificationTokenOutput{}
out.Result = output
var buff [1024]byte
@@ -17797,7 +17797,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolver) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamPrefixListResolverOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamExternalResourceVerificationTokenOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17811,7 +17811,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolver) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamExternalResourceVerificationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17844,14 +17844,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolver(response *smithy
}
}
-type awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget struct {
+type awsEc2query_deserializeOpDeleteIpamPolicy struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamPolicy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17869,9 +17869,9 @@ func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolverTarget(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPolicy(response, &metadata)
}
- output := &DeleteIpamPrefixListResolverTargetOutput{}
+ output := &DeleteIpamPolicyOutput{}
out.Result = output
var buff [1024]byte
@@ -17892,7 +17892,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamPrefixListResolverTargetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamPolicyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -17906,7 +17906,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -17939,14 +17939,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolverTarget(response *
}
}
-type awsEc2query_deserializeOpDeleteIpamResourceDiscovery struct {
+type awsEc2query_deserializeOpDeleteIpamPool struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamResourceDiscovery) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamPool) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -17964,9 +17964,9 @@ func (m *awsEc2query_deserializeOpDeleteIpamResourceDiscovery) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPool(response, &metadata)
}
- output := &DeleteIpamResourceDiscoveryOutput{}
+ output := &DeleteIpamPoolOutput{}
out.Result = output
var buff [1024]byte
@@ -17987,7 +17987,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamResourceDiscovery) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamResourceDiscoveryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamPoolOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18001,7 +18001,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamResourceDiscovery) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18034,14 +18034,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response *smithyh
}
}
-type awsEc2query_deserializeOpDeleteIpamScope struct {
+type awsEc2query_deserializeOpDeleteIpamPrefixListResolver struct {
}
-func (*awsEc2query_deserializeOpDeleteIpamScope) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamPrefixListResolver) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18059,9 +18059,9 @@ func (m *awsEc2query_deserializeOpDeleteIpamScope) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamScope(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolver(response, &metadata)
}
- output := &DeleteIpamScopeOutput{}
+ output := &DeleteIpamPrefixListResolverOutput{}
out.Result = output
var buff [1024]byte
@@ -18082,7 +18082,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamScope) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteIpamScopeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamPrefixListResolverOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18096,7 +18096,7 @@ func (m *awsEc2query_deserializeOpDeleteIpamScope) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18129,14 +18129,14 @@ func awsEc2query_deserializeOpErrorDeleteIpamScope(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpDeleteKeyPair struct {
+type awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget struct {
}
-func (*awsEc2query_deserializeOpDeleteKeyPair) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18154,9 +18154,9 @@ func (m *awsEc2query_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteKeyPair(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolverTarget(response, &metadata)
}
- output := &DeleteKeyPairOutput{}
+ output := &DeleteIpamPrefixListResolverTargetOutput{}
out.Result = output
var buff [1024]byte
@@ -18177,7 +18177,7 @@ func (m *awsEc2query_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteKeyPairOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamPrefixListResolverTargetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18191,7 +18191,7 @@ func (m *awsEc2query_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18224,14 +18224,14 @@ func awsEc2query_deserializeOpErrorDeleteKeyPair(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDeleteLaunchTemplate struct {
+type awsEc2query_deserializeOpDeleteIpamResourceDiscovery struct {
}
-func (*awsEc2query_deserializeOpDeleteLaunchTemplate) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamResourceDiscovery) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18249,9 +18249,9 @@ func (m *awsEc2query_deserializeOpDeleteLaunchTemplate) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLaunchTemplate(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response, &metadata)
}
- output := &DeleteLaunchTemplateOutput{}
+ output := &DeleteIpamResourceDiscoveryOutput{}
out.Result = output
var buff [1024]byte
@@ -18272,7 +18272,7 @@ func (m *awsEc2query_deserializeOpDeleteLaunchTemplate) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLaunchTemplateOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamResourceDiscoveryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18286,7 +18286,7 @@ func (m *awsEc2query_deserializeOpDeleteLaunchTemplate) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18319,14 +18319,14 @@ func awsEc2query_deserializeOpErrorDeleteLaunchTemplate(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDeleteLaunchTemplateVersions struct {
+type awsEc2query_deserializeOpDeleteIpamScope struct {
}
-func (*awsEc2query_deserializeOpDeleteLaunchTemplateVersions) ID() string {
+func (*awsEc2query_deserializeOpDeleteIpamScope) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLaunchTemplateVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18344,9 +18344,9 @@ func (m *awsEc2query_deserializeOpDeleteLaunchTemplateVersions) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLaunchTemplateVersions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteIpamScope(response, &metadata)
}
- output := &DeleteLaunchTemplateVersionsOutput{}
+ output := &DeleteIpamScopeOutput{}
out.Result = output
var buff [1024]byte
@@ -18367,7 +18367,7 @@ func (m *awsEc2query_deserializeOpDeleteLaunchTemplateVersions) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLaunchTemplateVersionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteIpamScopeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18381,7 +18381,7 @@ func (m *awsEc2query_deserializeOpDeleteLaunchTemplateVersions) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLaunchTemplateVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18414,14 +18414,14 @@ func awsEc2query_deserializeOpErrorDeleteLaunchTemplateVersions(response *smithy
}
}
-type awsEc2query_deserializeOpDeleteLocalGatewayRoute struct {
+type awsEc2query_deserializeOpDeleteKeyPair struct {
}
-func (*awsEc2query_deserializeOpDeleteLocalGatewayRoute) ID() string {
+func (*awsEc2query_deserializeOpDeleteKeyPair) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteKeyPair) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18439,9 +18439,9 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRoute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteKeyPair(response, &metadata)
}
- output := &DeleteLocalGatewayRouteOutput{}
+ output := &DeleteKeyPairOutput{}
out.Result = output
var buff [1024]byte
@@ -18462,7 +18462,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRoute) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteKeyPairOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18476,7 +18476,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRoute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteKeyPair(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18509,14 +18509,14 @@ func awsEc2query_deserializeOpErrorDeleteLocalGatewayRoute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDeleteLocalGatewayRouteTable struct {
+type awsEc2query_deserializeOpDeleteLaunchTemplate struct {
}
-func (*awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) ID() string {
+func (*awsEc2query_deserializeOpDeleteLaunchTemplate) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18534,9 +18534,9 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTable(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLaunchTemplate(response, &metadata)
}
- output := &DeleteLocalGatewayRouteTableOutput{}
+ output := &DeleteLaunchTemplateOutput{}
out.Result = output
var buff [1024]byte
@@ -18557,7 +18557,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteTableOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLaunchTemplateOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18571,7 +18571,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18604,14 +18604,14 @@ func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTable(response *smithy
}
}
-type awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
+type awsEc2query_deserializeOpDeleteLaunchTemplateVersions struct {
}
-func (*awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation) ID() string {
+func (*awsEc2query_deserializeOpDeleteLaunchTemplateVersions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLaunchTemplateVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18629,9 +18629,9 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGr
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLaunchTemplateVersions(response, &metadata)
}
- output := &DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput{}
+ output := &DeleteLaunchTemplateVersionsOutput{}
out.Result = output
var buff [1024]byte
@@ -18652,7 +18652,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGr
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLaunchTemplateVersionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18666,7 +18666,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGr
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLaunchTemplateVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18699,14 +18699,14 @@ func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVirtualInterfaceG
}
}
-type awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation struct {
+type awsEc2query_deserializeOpDeleteLocalGatewayRoute struct {
}
-func (*awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) ID() string {
+func (*awsEc2query_deserializeOpDeleteLocalGatewayRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18724,9 +18724,9 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVpcAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRoute(response, &metadata)
}
- output := &DeleteLocalGatewayRouteTableVpcAssociationOutput{}
+ output := &DeleteLocalGatewayRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -18747,7 +18747,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteTableVpcAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18761,7 +18761,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVpcAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18794,14 +18794,14 @@ func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVpcAssociation(re
}
}
-type awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface struct {
+type awsEc2query_deserializeOpDeleteLocalGatewayRouteTable struct {
}
-func (*awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) ID() string {
+func (*awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTable) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18819,9 +18819,9 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTable(response, &metadata)
}
- output := &DeleteLocalGatewayVirtualInterfaceOutput{}
+ output := &DeleteLocalGatewayRouteTableOutput{}
out.Result = output
var buff [1024]byte
@@ -18842,7 +18842,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayVirtualInterfaceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteTableOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18856,7 +18856,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTable(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18889,14 +18889,14 @@ func awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterface(response *
}
}
-type awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup struct {
+type awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation struct {
}
-func (*awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) ID() string {
+func (*awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -18914,9 +18914,9 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterfaceGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response, &metadata)
}
- output := &DeleteLocalGatewayVirtualInterfaceGroupOutput{}
+ output := &DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput{}
out.Result = output
var buff [1024]byte
@@ -18937,7 +18937,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayVirtualInterfaceGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -18951,7 +18951,7 @@ func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterfaceGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -18984,14 +18984,14 @@ func awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterfaceGroup(respo
}
}
-type awsEc2query_deserializeOpDeleteManagedPrefixList struct {
+type awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation struct {
}
-func (*awsEc2query_deserializeOpDeleteManagedPrefixList) ID() string {
+func (*awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLocalGatewayRouteTableVpcAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19009,9 +19009,9 @@ func (m *awsEc2query_deserializeOpDeleteManagedPrefixList) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteManagedPrefixList(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVpcAssociation(response, &metadata)
}
- output := &DeleteManagedPrefixListOutput{}
+ output := &DeleteLocalGatewayRouteTableVpcAssociationOutput{}
out.Result = output
var buff [1024]byte
@@ -19032,7 +19032,7 @@ func (m *awsEc2query_deserializeOpDeleteManagedPrefixList) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteManagedPrefixListOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayRouteTableVpcAssociationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19046,7 +19046,7 @@ func (m *awsEc2query_deserializeOpDeleteManagedPrefixList) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLocalGatewayRouteTableVpcAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19079,14 +19079,14 @@ func awsEc2query_deserializeOpErrorDeleteManagedPrefixList(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDeleteNatGateway struct {
+type awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface struct {
}
-func (*awsEc2query_deserializeOpDeleteNatGateway) ID() string {
+func (*awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNatGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19104,9 +19104,9 @@ func (m *awsEc2query_deserializeOpDeleteNatGateway) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNatGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterface(response, &metadata)
}
- output := &DeleteNatGatewayOutput{}
+ output := &DeleteLocalGatewayVirtualInterfaceOutput{}
out.Result = output
var buff [1024]byte
@@ -19127,7 +19127,7 @@ func (m *awsEc2query_deserializeOpDeleteNatGateway) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteNatGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayVirtualInterfaceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19141,7 +19141,7 @@ func (m *awsEc2query_deserializeOpDeleteNatGateway) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNatGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19174,14 +19174,14 @@ func awsEc2query_deserializeOpErrorDeleteNatGateway(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDeleteNetworkAcl struct {
+type awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkAcl) ID() string {
+func (*awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteLocalGatewayVirtualInterfaceGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19199,21 +19199,44 @@ func (m *awsEc2query_deserializeOpDeleteNetworkAcl) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkAcl(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterfaceGroup(response, &metadata)
}
- output := &DeleteNetworkAclOutput{}
+ output := &DeleteLocalGatewayVirtualInterfaceGroupOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeleteLocalGatewayVirtualInterfaceGroupOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteLocalGatewayVirtualInterfaceGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19246,14 +19269,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkAcl(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDeleteNetworkAclEntry struct {
+type awsEc2query_deserializeOpDeleteManagedPrefixList struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkAclEntry) ID() string {
+func (*awsEc2query_deserializeOpDeleteManagedPrefixList) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19271,21 +19294,44 @@ func (m *awsEc2query_deserializeOpDeleteNetworkAclEntry) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkAclEntry(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteManagedPrefixList(response, &metadata)
}
- output := &DeleteNetworkAclEntryOutput{}
+ output := &DeleteManagedPrefixListOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeleteManagedPrefixListOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19318,14 +19364,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkAclEntry(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope struct {
+type awsEc2query_deserializeOpDeleteNatGateway struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) ID() string {
+func (*awsEc2query_deserializeOpDeleteNatGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNatGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19343,9 +19389,9 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScope(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNatGateway(response, &metadata)
}
- output := &DeleteNetworkInsightsAccessScopeOutput{}
+ output := &DeleteNatGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -19366,7 +19412,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsAccessScopeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteNatGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19380,7 +19426,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNatGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19413,14 +19459,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScope(response *sm
}
}
-type awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis struct {
+type awsEc2query_deserializeOpDeleteNetworkAcl struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkAcl) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkAcl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19438,44 +19484,93 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis) Hand
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScopeAnalysis(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkAcl(response, &metadata)
}
- output := &DeleteNetworkInsightsAccessScopeAnalysisOutput{}
+ output := &DeleteNetworkAclOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsAccessScopeAnalysisOutput(&output, decoder)
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDeleteNetworkAcl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
}
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDeleteNetworkAclEntry struct {
+}
+
+func (*awsEc2query_deserializeOpDeleteNetworkAclEntry) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDeleteNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
return out, metadata, err
}
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkAclEntry(response, &metadata)
+ }
+ output := &DeleteNetworkAclEntryOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScopeAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19508,14 +19603,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScopeAnalysis(resp
}
}
-type awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis struct {
+type awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19533,9 +19628,9 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsAnalysis(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScope(response, &metadata)
}
- output := &DeleteNetworkInsightsAnalysisOutput{}
+ output := &DeleteNetworkInsightsAccessScopeOutput{}
out.Result = output
var buff [1024]byte
@@ -19556,7 +19651,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsAnalysisOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsAccessScopeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19570,7 +19665,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19603,14 +19698,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAnalysis(response *smith
}
}
-type awsEc2query_deserializeOpDeleteNetworkInsightsPath struct {
+type awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkInsightsPath) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkInsightsPath) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAccessScopeAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19628,9 +19723,9 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsPath) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsPath(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScopeAnalysis(response, &metadata)
}
- output := &DeleteNetworkInsightsPathOutput{}
+ output := &DeleteNetworkInsightsAccessScopeAnalysisOutput{}
out.Result = output
var buff [1024]byte
@@ -19651,7 +19746,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsPath) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsPathOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsAccessScopeAnalysisOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19665,7 +19760,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInsightsPath) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkInsightsPath(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAccessScopeAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19698,14 +19793,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkInsightsPath(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDeleteNetworkInterface struct {
+type awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkInterface) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkInsightsAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19723,21 +19818,44 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInterface) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsAnalysis(response, &metadata)
}
- output := &DeleteNetworkInterfaceOutput{}
+ output := &DeleteNetworkInsightsAnalysisOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsAnalysisOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkInsightsAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19770,14 +19888,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkInterface(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDeleteNetworkInterfacePermission struct {
+type awsEc2query_deserializeOpDeleteNetworkInsightsPath struct {
}
-func (*awsEc2query_deserializeOpDeleteNetworkInterfacePermission) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkInsightsPath) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeleteNetworkInterfacePermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkInsightsPath) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19795,9 +19913,9 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInterfacePermission) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInterfacePermission(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInsightsPath(response, &metadata)
}
- output := &DeleteNetworkInterfacePermissionOutput{}
+ output := &DeleteNetworkInsightsPathOutput{}
out.Result = output
var buff [1024]byte
@@ -19818,7 +19936,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInterfacePermission) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeleteNetworkInterfacePermissionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteNetworkInsightsPathOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19832,7 +19950,7 @@ func (m *awsEc2query_deserializeOpDeleteNetworkInterfacePermission) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeleteNetworkInterfacePermission(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkInsightsPath(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19865,14 +19983,14 @@ func awsEc2query_deserializeOpErrorDeleteNetworkInterfacePermission(response *sm
}
}
-type awsEc2query_deserializeOpDeletePlacementGroup struct {
+type awsEc2query_deserializeOpDeleteNetworkInterface struct {
}
-func (*awsEc2query_deserializeOpDeletePlacementGroup) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkInterface) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeletePlacementGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19890,9 +20008,9 @@ func (m *awsEc2query_deserializeOpDeletePlacementGroup) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeletePlacementGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInterface(response, &metadata)
}
- output := &DeletePlacementGroupOutput{}
+ output := &DeleteNetworkInterfaceOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -19904,7 +20022,7 @@ func (m *awsEc2query_deserializeOpDeletePlacementGroup) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeletePlacementGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -19937,14 +20055,14 @@ func awsEc2query_deserializeOpErrorDeletePlacementGroup(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDeletePublicIpv4Pool struct {
+type awsEc2query_deserializeOpDeleteNetworkInterfacePermission struct {
}
-func (*awsEc2query_deserializeOpDeletePublicIpv4Pool) ID() string {
+func (*awsEc2query_deserializeOpDeleteNetworkInterfacePermission) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDeletePublicIpv4Pool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDeleteNetworkInterfacePermission) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -19962,9 +20080,9 @@ func (m *awsEc2query_deserializeOpDeletePublicIpv4Pool) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDeletePublicIpv4Pool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDeleteNetworkInterfacePermission(response, &metadata)
}
- output := &DeletePublicIpv4PoolOutput{}
+ output := &DeleteNetworkInterfacePermissionOutput{}
out.Result = output
var buff [1024]byte
@@ -19985,7 +20103,7 @@ func (m *awsEc2query_deserializeOpDeletePublicIpv4Pool) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDeletePublicIpv4PoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDeleteNetworkInterfacePermissionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -19999,7 +20117,174 @@ func (m *awsEc2query_deserializeOpDeletePublicIpv4Pool) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDeletePublicIpv4Pool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDeleteNetworkInterfacePermission(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDeletePlacementGroup struct {
+}
+
+func (*awsEc2query_deserializeOpDeletePlacementGroup) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDeletePlacementGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDeletePlacementGroup(response, &metadata)
+ }
+ output := &DeletePlacementGroupOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDeletePlacementGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDeletePublicIpv4Pool struct {
+}
+
+func (*awsEc2query_deserializeOpDeletePublicIpv4Pool) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDeletePublicIpv4Pool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDeletePublicIpv4Pool(response, &metadata)
+ }
+ output := &DeletePublicIpv4PoolOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDeletePublicIpv4PoolOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDeletePublicIpv4Pool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -25764,14 +26049,14 @@ func awsEc2query_deserializeOpErrorDescribeAggregateIdFormat(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeAvailabilityZones struct {
+type awsEc2query_deserializeOpDescribeApplicationStatus struct {
}
-func (*awsEc2query_deserializeOpDescribeAvailabilityZones) ID() string {
+func (*awsEc2query_deserializeOpDescribeApplicationStatus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeAvailabilityZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeApplicationStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -25789,9 +26074,9 @@ func (m *awsEc2query_deserializeOpDescribeAvailabilityZones) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeAvailabilityZones(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeApplicationStatus(response, &metadata)
}
- output := &DescribeAvailabilityZonesOutput{}
+ output := &DescribeApplicationStatusOutput{}
out.Result = output
var buff [1024]byte
@@ -25812,7 +26097,7 @@ func (m *awsEc2query_deserializeOpDescribeAvailabilityZones) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeAvailabilityZonesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeApplicationStatusOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -25826,7 +26111,7 @@ func (m *awsEc2query_deserializeOpDescribeAvailabilityZones) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeAvailabilityZones(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeApplicationStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -25859,14 +26144,14 @@ func awsEc2query_deserializeOpErrorDescribeAvailabilityZones(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptions struct {
+type awsEc2query_deserializeOpDescribeApplicationStatusCheckAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) ID() string {
+func (*awsEc2query_deserializeOpDescribeApplicationStatusCheckAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeApplicationStatusCheckAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -25884,9 +26169,9 @@ func (m *awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptio
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeAwsNetworkPerformanceMetricSubscriptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeApplicationStatusCheckAssociations(response, &metadata)
}
- output := &DescribeAwsNetworkPerformanceMetricSubscriptionsOutput{}
+ output := &DescribeApplicationStatusCheckAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -25907,7 +26192,7 @@ func (m *awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptio
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeAwsNetworkPerformanceMetricSubscriptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeApplicationStatusCheckAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -25921,7 +26206,7 @@ func (m *awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptio
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeAwsNetworkPerformanceMetricSubscriptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeApplicationStatusCheckAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -25954,14 +26239,14 @@ func awsEc2query_deserializeOpErrorDescribeAwsNetworkPerformanceMetricSubscripti
}
}
-type awsEc2query_deserializeOpDescribeBundleTasks struct {
+type awsEc2query_deserializeOpDescribeApplicationStatusChecks struct {
}
-func (*awsEc2query_deserializeOpDescribeBundleTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeApplicationStatusChecks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeBundleTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeApplicationStatusChecks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -25979,9 +26264,9 @@ func (m *awsEc2query_deserializeOpDescribeBundleTasks) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeBundleTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeApplicationStatusChecks(response, &metadata)
}
- output := &DescribeBundleTasksOutput{}
+ output := &DescribeApplicationStatusChecksOutput{}
out.Result = output
var buff [1024]byte
@@ -26002,7 +26287,7 @@ func (m *awsEc2query_deserializeOpDescribeBundleTasks) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeBundleTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeApplicationStatusChecksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26016,7 +26301,7 @@ func (m *awsEc2query_deserializeOpDescribeBundleTasks) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeBundleTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeApplicationStatusChecks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26049,14 +26334,14 @@ func awsEc2query_deserializeOpErrorDescribeBundleTasks(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeByoipCidrs struct {
+type awsEc2query_deserializeOpDescribeAvailabilityZones struct {
}
-func (*awsEc2query_deserializeOpDescribeByoipCidrs) ID() string {
+func (*awsEc2query_deserializeOpDescribeAvailabilityZones) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeByoipCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeAvailabilityZones) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26074,9 +26359,9 @@ func (m *awsEc2query_deserializeOpDescribeByoipCidrs) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeByoipCidrs(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeAvailabilityZones(response, &metadata)
}
- output := &DescribeByoipCidrsOutput{}
+ output := &DescribeAvailabilityZonesOutput{}
out.Result = output
var buff [1024]byte
@@ -26097,7 +26382,7 @@ func (m *awsEc2query_deserializeOpDescribeByoipCidrs) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeByoipCidrsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeAvailabilityZonesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26111,7 +26396,7 @@ func (m *awsEc2query_deserializeOpDescribeByoipCidrs) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeByoipCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeAvailabilityZones(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26144,14 +26429,14 @@ func awsEc2query_deserializeOpErrorDescribeByoipCidrs(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory struct {
+type awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptions struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) ID() string {
+func (*awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26169,9 +26454,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionHistory(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeAwsNetworkPerformanceMetricSubscriptions(response, &metadata)
}
- output := &DescribeCapacityBlockExtensionHistoryOutput{}
+ output := &DescribeAwsNetworkPerformanceMetricSubscriptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -26192,7 +26477,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockExtensionHistoryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeAwsNetworkPerformanceMetricSubscriptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26206,7 +26491,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeAwsNetworkPerformanceMetricSubscriptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26239,14 +26524,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionHistory(respons
}
}
-type awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings struct {
+type awsEc2query_deserializeOpDescribeBundleTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) ID() string {
+func (*awsEc2query_deserializeOpDescribeBundleTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeBundleTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26264,9 +26549,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionOfferings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeBundleTasks(response, &metadata)
}
- output := &DescribeCapacityBlockExtensionOfferingsOutput{}
+ output := &DescribeBundleTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -26287,7 +26572,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockExtensionOfferingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeBundleTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26301,7 +26586,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeBundleTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26334,14 +26619,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionOfferings(respo
}
}
-type awsEc2query_deserializeOpDescribeCapacityBlockOfferings struct {
+type awsEc2query_deserializeOpDescribeByoipCidrs struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityBlockOfferings) ID() string {
+func (*awsEc2query_deserializeOpDescribeByoipCidrs) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityBlockOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeByoipCidrs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26359,9 +26644,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockOfferings) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockOfferings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeByoipCidrs(response, &metadata)
}
- output := &DescribeCapacityBlockOfferingsOutput{}
+ output := &DescribeByoipCidrsOutput{}
out.Result = output
var buff [1024]byte
@@ -26382,7 +26667,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockOfferings) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockOfferingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeByoipCidrsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26396,7 +26681,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockOfferings) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityBlockOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeByoipCidrs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26429,14 +26714,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityBlockOfferings(response *smit
}
}
-type awsEc2query_deserializeOpDescribeCapacityBlocks struct {
+type awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityBlocks) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26454,9 +26739,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlocks) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlocks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionHistory(response, &metadata)
}
- output := &DescribeCapacityBlocksOutput{}
+ output := &DescribeCapacityBlockExtensionHistoryOutput{}
out.Result = output
var buff [1024]byte
@@ -26477,7 +26762,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlocks) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityBlocksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockExtensionHistoryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26491,7 +26776,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlocks) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26524,14 +26809,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityBlocks(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeCapacityBlockStatus struct {
+type awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityBlockStatus) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityBlockStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityBlockExtensionOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26549,9 +26834,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockStatus) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockStatus(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionOfferings(response, &metadata)
}
- output := &DescribeCapacityBlockStatusOutput{}
+ output := &DescribeCapacityBlockExtensionOfferingsOutput{}
out.Result = output
var buff [1024]byte
@@ -26572,7 +26857,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockStatus) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockStatusOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockExtensionOfferingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26586,7 +26871,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityBlockStatus) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityBlockStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityBlockExtensionOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26619,14 +26904,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityBlockStatus(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeCapacityManagerDataExports struct {
+type awsEc2query_deserializeOpDescribeCapacityBlockOfferings struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityManagerDataExports) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityBlockOfferings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityManagerDataExports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityBlockOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26644,9 +26929,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityManagerDataExports) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityManagerDataExports(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockOfferings(response, &metadata)
}
- output := &DescribeCapacityManagerDataExportsOutput{}
+ output := &DescribeCapacityBlockOfferingsOutput{}
out.Result = output
var buff [1024]byte
@@ -26667,7 +26952,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityManagerDataExports) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityManagerDataExportsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockOfferingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26681,7 +26966,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityManagerDataExports) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityManagerDataExports(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityBlockOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26714,14 +26999,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityManagerDataExports(response *
}
}
-type awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests struct {
+type awsEc2query_deserializeOpDescribeCapacityBlocks struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityBlocks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26739,9 +27024,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationBillingRequests(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlocks(response, &metadata)
}
- output := &DescribeCapacityReservationBillingRequestsOutput{}
+ output := &DescribeCapacityBlocksOutput{}
out.Result = output
var buff [1024]byte
@@ -26762,7 +27047,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationBillingRequestsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityBlocksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26776,7 +27061,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityReservationBillingRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26809,14 +27094,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityReservationBillingRequests(re
}
}
-type awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes struct {
+type awsEc2query_deserializeOpDescribeCapacityBlockStatus struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityBlockStatus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityBlockStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26834,9 +27119,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes)
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationCancellationQuotes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityBlockStatus(response, &metadata)
}
- output := &DescribeCapacityReservationCancellationQuotesOutput{}
+ output := &DescribeCapacityBlockStatusOutput{}
out.Result = output
var buff [1024]byte
@@ -26857,7 +27142,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes)
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationCancellationQuotesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityBlockStatusOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26871,7 +27156,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes)
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityReservationCancellationQuotes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityBlockStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26904,14 +27189,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityReservationCancellationQuotes
}
}
-type awsEc2query_deserializeOpDescribeCapacityReservationFleets struct {
+type awsEc2query_deserializeOpDescribeCapacityManagerDataExports struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityReservationFleets) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityManagerDataExports) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityReservationFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityManagerDataExports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -26929,9 +27214,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationFleets) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationFleets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityManagerDataExports(response, &metadata)
}
- output := &DescribeCapacityReservationFleetsOutput{}
+ output := &DescribeCapacityManagerDataExportsOutput{}
out.Result = output
var buff [1024]byte
@@ -26952,7 +27237,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationFleets) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationFleetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityManagerDataExportsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -26966,7 +27251,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationFleets) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityReservationFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityManagerDataExports(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -26999,14 +27284,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityReservationFleets(response *s
}
}
-type awsEc2query_deserializeOpDescribeCapacityReservations struct {
+type awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityReservations) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityReservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityReservationBillingRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27024,9 +27309,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservations) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationBillingRequests(response, &metadata)
}
- output := &DescribeCapacityReservationsOutput{}
+ output := &DescribeCapacityReservationBillingRequestsOutput{}
out.Result = output
var buff [1024]byte
@@ -27047,7 +27332,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservations) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationBillingRequestsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27061,7 +27346,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservations) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityReservations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityReservationBillingRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27094,14 +27379,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityReservations(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeCapacityReservationTopology struct {
+type awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes struct {
}
-func (*awsEc2query_deserializeOpDescribeCapacityReservationTopology) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCapacityReservationTopology) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityReservationCancellationQuotes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27119,9 +27404,9 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationTopology) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationTopology(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationCancellationQuotes(response, &metadata)
}
- output := &DescribeCapacityReservationTopologyOutput{}
+ output := &DescribeCapacityReservationCancellationQuotesOutput{}
out.Result = output
var buff [1024]byte
@@ -27142,7 +27427,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationTopology) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationTopologyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationCancellationQuotesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27156,7 +27441,7 @@ func (m *awsEc2query_deserializeOpDescribeCapacityReservationTopology) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCapacityReservationTopology(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityReservationCancellationQuotes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27189,14 +27474,14 @@ func awsEc2query_deserializeOpErrorDescribeCapacityReservationTopology(response
}
}
-type awsEc2query_deserializeOpDescribeCarrierGateways struct {
+type awsEc2query_deserializeOpDescribeCapacityReservationFleets struct {
}
-func (*awsEc2query_deserializeOpDescribeCarrierGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityReservationFleets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCarrierGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityReservationFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27214,9 +27499,9 @@ func (m *awsEc2query_deserializeOpDescribeCarrierGateways) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCarrierGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationFleets(response, &metadata)
}
- output := &DescribeCarrierGatewaysOutput{}
+ output := &DescribeCapacityReservationFleetsOutput{}
out.Result = output
var buff [1024]byte
@@ -27237,7 +27522,7 @@ func (m *awsEc2query_deserializeOpDescribeCarrierGateways) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCarrierGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationFleetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27251,7 +27536,7 @@ func (m *awsEc2query_deserializeOpDescribeCarrierGateways) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCarrierGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityReservationFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27284,14 +27569,14 @@ func awsEc2query_deserializeOpErrorDescribeCarrierGateways(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeClassicLinkInstances struct {
+type awsEc2query_deserializeOpDescribeCapacityReservations struct {
}
-func (*awsEc2query_deserializeOpDescribeClassicLinkInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityReservations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeClassicLinkInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityReservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27309,9 +27594,9 @@ func (m *awsEc2query_deserializeOpDescribeClassicLinkInstances) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeClassicLinkInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservations(response, &metadata)
}
- output := &DescribeClassicLinkInstancesOutput{}
+ output := &DescribeCapacityReservationsOutput{}
out.Result = output
var buff [1024]byte
@@ -27332,7 +27617,7 @@ func (m *awsEc2query_deserializeOpDescribeClassicLinkInstances) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeClassicLinkInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27346,7 +27631,7 @@ func (m *awsEc2query_deserializeOpDescribeClassicLinkInstances) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeClassicLinkInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityReservations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27379,14 +27664,14 @@ func awsEc2query_deserializeOpErrorDescribeClassicLinkInstances(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules struct {
+type awsEc2query_deserializeOpDescribeCapacityReservationTopology struct {
}
-func (*awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) ID() string {
+func (*awsEc2query_deserializeOpDescribeCapacityReservationTopology) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCapacityReservationTopology) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27404,9 +27689,9 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnAuthorizationRules(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCapacityReservationTopology(response, &metadata)
}
- output := &DescribeClientVpnAuthorizationRulesOutput{}
+ output := &DescribeCapacityReservationTopologyOutput{}
out.Result = output
var buff [1024]byte
@@ -27427,7 +27712,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeClientVpnAuthorizationRulesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCapacityReservationTopologyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27441,7 +27726,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeClientVpnAuthorizationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCapacityReservationTopology(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27474,14 +27759,14 @@ func awsEc2query_deserializeOpErrorDescribeClientVpnAuthorizationRules(response
}
}
-type awsEc2query_deserializeOpDescribeClientVpnConnections struct {
+type awsEc2query_deserializeOpDescribeCarrierGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeClientVpnConnections) ID() string {
+func (*awsEc2query_deserializeOpDescribeCarrierGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeClientVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCarrierGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27499,9 +27784,9 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnConnections) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnConnections(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCarrierGateways(response, &metadata)
}
- output := &DescribeClientVpnConnectionsOutput{}
+ output := &DescribeCarrierGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -27522,7 +27807,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnConnections) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeClientVpnConnectionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCarrierGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27536,7 +27821,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnConnections) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeClientVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCarrierGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27569,14 +27854,14 @@ func awsEc2query_deserializeOpErrorDescribeClientVpnConnections(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeClientVpnEndpoints struct {
+type awsEc2query_deserializeOpDescribeClassicLinkInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeClientVpnEndpoints) ID() string {
+func (*awsEc2query_deserializeOpDescribeClassicLinkInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeClientVpnEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeClassicLinkInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27594,9 +27879,9 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnEndpoints) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnEndpoints(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeClassicLinkInstances(response, &metadata)
}
- output := &DescribeClientVpnEndpointsOutput{}
+ output := &DescribeClassicLinkInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -27617,7 +27902,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnEndpoints) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeClientVpnEndpointsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeClassicLinkInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27631,7 +27916,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnEndpoints) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeClientVpnEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeClassicLinkInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27664,14 +27949,14 @@ func awsEc2query_deserializeOpErrorDescribeClientVpnEndpoints(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeClientVpnRoutes struct {
+type awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules struct {
}
-func (*awsEc2query_deserializeOpDescribeClientVpnRoutes) ID() string {
+func (*awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeClientVpnRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeClientVpnAuthorizationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27689,9 +27974,9 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnRoutes) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnRoutes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnAuthorizationRules(response, &metadata)
}
- output := &DescribeClientVpnRoutesOutput{}
+ output := &DescribeClientVpnAuthorizationRulesOutput{}
out.Result = output
var buff [1024]byte
@@ -27712,7 +27997,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnRoutes) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeClientVpnRoutesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeClientVpnAuthorizationRulesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27726,7 +28011,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnRoutes) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeClientVpnRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeClientVpnAuthorizationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27759,14 +28044,14 @@ func awsEc2query_deserializeOpErrorDescribeClientVpnRoutes(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeClientVpnTargetNetworks struct {
+type awsEc2query_deserializeOpDescribeClientVpnConnections struct {
}
-func (*awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) ID() string {
+func (*awsEc2query_deserializeOpDescribeClientVpnConnections) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeClientVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27784,9 +28069,9 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnTargetNetworks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnConnections(response, &metadata)
}
- output := &DescribeClientVpnTargetNetworksOutput{}
+ output := &DescribeClientVpnConnectionsOutput{}
out.Result = output
var buff [1024]byte
@@ -27807,7 +28092,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeClientVpnTargetNetworksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeClientVpnConnectionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27821,7 +28106,7 @@ func (m *awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeClientVpnTargetNetworks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeClientVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27854,14 +28139,14 @@ func awsEc2query_deserializeOpErrorDescribeClientVpnTargetNetworks(response *smi
}
}
-type awsEc2query_deserializeOpDescribeCoipPools struct {
+type awsEc2query_deserializeOpDescribeClientVpnEndpoints struct {
}
-func (*awsEc2query_deserializeOpDescribeCoipPools) ID() string {
+func (*awsEc2query_deserializeOpDescribeClientVpnEndpoints) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCoipPools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeClientVpnEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27879,9 +28164,9 @@ func (m *awsEc2query_deserializeOpDescribeCoipPools) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCoipPools(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnEndpoints(response, &metadata)
}
- output := &DescribeCoipPoolsOutput{}
+ output := &DescribeClientVpnEndpointsOutput{}
out.Result = output
var buff [1024]byte
@@ -27902,7 +28187,7 @@ func (m *awsEc2query_deserializeOpDescribeCoipPools) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCoipPoolsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeClientVpnEndpointsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -27916,7 +28201,7 @@ func (m *awsEc2query_deserializeOpDescribeCoipPools) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCoipPools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeClientVpnEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -27949,14 +28234,14 @@ func awsEc2query_deserializeOpErrorDescribeCoipPools(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDescribeConversionTasks struct {
+type awsEc2query_deserializeOpDescribeClientVpnRoutes struct {
}
-func (*awsEc2query_deserializeOpDescribeConversionTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeClientVpnRoutes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeConversionTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeClientVpnRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -27974,9 +28259,9 @@ func (m *awsEc2query_deserializeOpDescribeConversionTasks) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeConversionTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnRoutes(response, &metadata)
}
- output := &DescribeConversionTasksOutput{}
+ output := &DescribeClientVpnRoutesOutput{}
out.Result = output
var buff [1024]byte
@@ -27997,7 +28282,7 @@ func (m *awsEc2query_deserializeOpDescribeConversionTasks) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeConversionTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeClientVpnRoutesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28011,7 +28296,7 @@ func (m *awsEc2query_deserializeOpDescribeConversionTasks) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeConversionTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeClientVpnRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28044,14 +28329,14 @@ func awsEc2query_deserializeOpErrorDescribeConversionTasks(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeCustomerGateways struct {
+type awsEc2query_deserializeOpDescribeClientVpnTargetNetworks struct {
}
-func (*awsEc2query_deserializeOpDescribeCustomerGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeCustomerGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeClientVpnTargetNetworks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28069,9 +28354,9 @@ func (m *awsEc2query_deserializeOpDescribeCustomerGateways) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeCustomerGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeClientVpnTargetNetworks(response, &metadata)
}
- output := &DescribeCustomerGatewaysOutput{}
+ output := &DescribeClientVpnTargetNetworksOutput{}
out.Result = output
var buff [1024]byte
@@ -28092,7 +28377,7 @@ func (m *awsEc2query_deserializeOpDescribeCustomerGateways) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeCustomerGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeClientVpnTargetNetworksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28106,7 +28391,7 @@ func (m *awsEc2query_deserializeOpDescribeCustomerGateways) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeCustomerGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeClientVpnTargetNetworks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28139,14 +28424,14 @@ func awsEc2query_deserializeOpErrorDescribeCustomerGateways(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeDeclarativePoliciesReports struct {
+type awsEc2query_deserializeOpDescribeCoipPools struct {
}
-func (*awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) ID() string {
+func (*awsEc2query_deserializeOpDescribeCoipPools) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCoipPools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28164,9 +28449,9 @@ func (m *awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeDeclarativePoliciesReports(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCoipPools(response, &metadata)
}
- output := &DescribeDeclarativePoliciesReportsOutput{}
+ output := &DescribeCoipPoolsOutput{}
out.Result = output
var buff [1024]byte
@@ -28187,7 +28472,7 @@ func (m *awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeDeclarativePoliciesReportsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCoipPoolsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28201,7 +28486,7 @@ func (m *awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeDeclarativePoliciesReports(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCoipPools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28234,14 +28519,14 @@ func awsEc2query_deserializeOpErrorDescribeDeclarativePoliciesReports(response *
}
}
-type awsEc2query_deserializeOpDescribeDhcpOptions struct {
+type awsEc2query_deserializeOpDescribeConversionTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeDhcpOptions) ID() string {
+func (*awsEc2query_deserializeOpDescribeConversionTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeConversionTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28259,9 +28544,9 @@ func (m *awsEc2query_deserializeOpDescribeDhcpOptions) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeDhcpOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeConversionTasks(response, &metadata)
}
- output := &DescribeDhcpOptionsOutput{}
+ output := &DescribeConversionTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -28282,7 +28567,7 @@ func (m *awsEc2query_deserializeOpDescribeDhcpOptions) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeDhcpOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeConversionTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28296,7 +28581,7 @@ func (m *awsEc2query_deserializeOpDescribeDhcpOptions) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeConversionTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28329,14 +28614,14 @@ func awsEc2query_deserializeOpErrorDescribeDhcpOptions(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways struct {
+type awsEc2query_deserializeOpDescribeCustomerGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeCustomerGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeCustomerGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28354,9 +28639,9 @@ func (m *awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeEgressOnlyInternetGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeCustomerGateways(response, &metadata)
}
- output := &DescribeEgressOnlyInternetGatewaysOutput{}
+ output := &DescribeCustomerGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -28377,7 +28662,7 @@ func (m *awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeEgressOnlyInternetGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeCustomerGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28391,7 +28676,7 @@ func (m *awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeEgressOnlyInternetGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeCustomerGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28424,14 +28709,14 @@ func awsEc2query_deserializeOpErrorDescribeEgressOnlyInternetGateways(response *
}
}
-type awsEc2query_deserializeOpDescribeElasticGpus struct {
+type awsEc2query_deserializeOpDescribeDeclarativePoliciesReports struct {
}
-func (*awsEc2query_deserializeOpDescribeElasticGpus) ID() string {
+func (*awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeElasticGpus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeDeclarativePoliciesReports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28449,9 +28734,9 @@ func (m *awsEc2query_deserializeOpDescribeElasticGpus) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeElasticGpus(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeDeclarativePoliciesReports(response, &metadata)
}
- output := &DescribeElasticGpusOutput{}
+ output := &DescribeDeclarativePoliciesReportsOutput{}
out.Result = output
var buff [1024]byte
@@ -28472,7 +28757,7 @@ func (m *awsEc2query_deserializeOpDescribeElasticGpus) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeElasticGpusOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeDeclarativePoliciesReportsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28486,7 +28771,7 @@ func (m *awsEc2query_deserializeOpDescribeElasticGpus) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeElasticGpus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeDeclarativePoliciesReports(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28519,14 +28804,14 @@ func awsEc2query_deserializeOpErrorDescribeElasticGpus(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeExportImageTasks struct {
+type awsEc2query_deserializeOpDescribeDhcpOptions struct {
}
-func (*awsEc2query_deserializeOpDescribeExportImageTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeDhcpOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeExportImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeDhcpOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28544,9 +28829,9 @@ func (m *awsEc2query_deserializeOpDescribeExportImageTasks) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeExportImageTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeDhcpOptions(response, &metadata)
}
- output := &DescribeExportImageTasksOutput{}
+ output := &DescribeDhcpOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -28567,7 +28852,7 @@ func (m *awsEc2query_deserializeOpDescribeExportImageTasks) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeExportImageTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeDhcpOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28581,7 +28866,7 @@ func (m *awsEc2query_deserializeOpDescribeExportImageTasks) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeExportImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeDhcpOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28614,14 +28899,14 @@ func awsEc2query_deserializeOpErrorDescribeExportImageTasks(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeExportTasks struct {
+type awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeExportTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeExportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeEgressOnlyInternetGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28639,9 +28924,9 @@ func (m *awsEc2query_deserializeOpDescribeExportTasks) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeExportTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeEgressOnlyInternetGateways(response, &metadata)
}
- output := &DescribeExportTasksOutput{}
+ output := &DescribeEgressOnlyInternetGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -28662,7 +28947,7 @@ func (m *awsEc2query_deserializeOpDescribeExportTasks) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeExportTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeEgressOnlyInternetGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28676,7 +28961,7 @@ func (m *awsEc2query_deserializeOpDescribeExportTasks) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeEgressOnlyInternetGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28709,14 +28994,14 @@ func awsEc2query_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeFastLaunchImages struct {
+type awsEc2query_deserializeOpDescribeElasticGpus struct {
}
-func (*awsEc2query_deserializeOpDescribeFastLaunchImages) ID() string {
+func (*awsEc2query_deserializeOpDescribeElasticGpus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFastLaunchImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeElasticGpus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28734,9 +29019,9 @@ func (m *awsEc2query_deserializeOpDescribeFastLaunchImages) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFastLaunchImages(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeElasticGpus(response, &metadata)
}
- output := &DescribeFastLaunchImagesOutput{}
+ output := &DescribeElasticGpusOutput{}
out.Result = output
var buff [1024]byte
@@ -28757,7 +29042,7 @@ func (m *awsEc2query_deserializeOpDescribeFastLaunchImages) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFastLaunchImagesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeElasticGpusOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28771,7 +29056,7 @@ func (m *awsEc2query_deserializeOpDescribeFastLaunchImages) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFastLaunchImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeElasticGpus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28804,14 +29089,14 @@ func awsEc2query_deserializeOpErrorDescribeFastLaunchImages(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeFastSnapshotRestores struct {
+type awsEc2query_deserializeOpDescribeExportImageTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeFastSnapshotRestores) ID() string {
+func (*awsEc2query_deserializeOpDescribeExportImageTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeExportImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28829,9 +29114,9 @@ func (m *awsEc2query_deserializeOpDescribeFastSnapshotRestores) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFastSnapshotRestores(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeExportImageTasks(response, &metadata)
}
- output := &DescribeFastSnapshotRestoresOutput{}
+ output := &DescribeExportImageTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -28852,7 +29137,7 @@ func (m *awsEc2query_deserializeOpDescribeFastSnapshotRestores) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFastSnapshotRestoresOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeExportImageTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28866,7 +29151,7 @@ func (m *awsEc2query_deserializeOpDescribeFastSnapshotRestores) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeExportImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28899,14 +29184,14 @@ func awsEc2query_deserializeOpErrorDescribeFastSnapshotRestores(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeFleetHistory struct {
+type awsEc2query_deserializeOpDescribeExportTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeFleetHistory) ID() string {
+func (*awsEc2query_deserializeOpDescribeExportTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFleetHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeExportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -28924,9 +29209,9 @@ func (m *awsEc2query_deserializeOpDescribeFleetHistory) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFleetHistory(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeExportTasks(response, &metadata)
}
- output := &DescribeFleetHistoryOutput{}
+ output := &DescribeExportTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -28947,7 +29232,7 @@ func (m *awsEc2query_deserializeOpDescribeFleetHistory) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFleetHistoryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeExportTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -28961,7 +29246,7 @@ func (m *awsEc2query_deserializeOpDescribeFleetHistory) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFleetHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -28994,14 +29279,14 @@ func awsEc2query_deserializeOpErrorDescribeFleetHistory(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDescribeFleetInstances struct {
+type awsEc2query_deserializeOpDescribeFastLaunchImages struct {
}
-func (*awsEc2query_deserializeOpDescribeFleetInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribeFastLaunchImages) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFleetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFastLaunchImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29019,9 +29304,9 @@ func (m *awsEc2query_deserializeOpDescribeFleetInstances) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFleetInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFastLaunchImages(response, &metadata)
}
- output := &DescribeFleetInstancesOutput{}
+ output := &DescribeFastLaunchImagesOutput{}
out.Result = output
var buff [1024]byte
@@ -29042,7 +29327,7 @@ func (m *awsEc2query_deserializeOpDescribeFleetInstances) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFleetInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFastLaunchImagesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29056,7 +29341,7 @@ func (m *awsEc2query_deserializeOpDescribeFleetInstances) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFleetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFastLaunchImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29089,14 +29374,14 @@ func awsEc2query_deserializeOpErrorDescribeFleetInstances(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeFleets struct {
+type awsEc2query_deserializeOpDescribeFastSnapshotRestores struct {
}
-func (*awsEc2query_deserializeOpDescribeFleets) ID() string {
+func (*awsEc2query_deserializeOpDescribeFastSnapshotRestores) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29114,9 +29399,9 @@ func (m *awsEc2query_deserializeOpDescribeFleets) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFleets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFastSnapshotRestores(response, &metadata)
}
- output := &DescribeFleetsOutput{}
+ output := &DescribeFastSnapshotRestoresOutput{}
out.Result = output
var buff [1024]byte
@@ -29137,7 +29422,7 @@ func (m *awsEc2query_deserializeOpDescribeFleets) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFleetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFastSnapshotRestoresOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29151,7 +29436,7 @@ func (m *awsEc2query_deserializeOpDescribeFleets) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29184,14 +29469,14 @@ func awsEc2query_deserializeOpErrorDescribeFleets(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDescribeFlowLogs struct {
+type awsEc2query_deserializeOpDescribeFleetHistory struct {
}
-func (*awsEc2query_deserializeOpDescribeFlowLogs) ID() string {
+func (*awsEc2query_deserializeOpDescribeFleetHistory) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFlowLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFleetHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29209,9 +29494,9 @@ func (m *awsEc2query_deserializeOpDescribeFlowLogs) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFlowLogs(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFleetHistory(response, &metadata)
}
- output := &DescribeFlowLogsOutput{}
+ output := &DescribeFleetHistoryOutput{}
out.Result = output
var buff [1024]byte
@@ -29232,7 +29517,7 @@ func (m *awsEc2query_deserializeOpDescribeFlowLogs) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFlowLogsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFleetHistoryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29246,7 +29531,7 @@ func (m *awsEc2query_deserializeOpDescribeFlowLogs) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFlowLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFleetHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29279,14 +29564,14 @@ func awsEc2query_deserializeOpErrorDescribeFlowLogs(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDescribeFpgaImageAttribute struct {
+type awsEc2query_deserializeOpDescribeFleetInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeFpgaImageAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeFleetInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFleetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29304,9 +29589,9 @@ func (m *awsEc2query_deserializeOpDescribeFpgaImageAttribute) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFpgaImageAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFleetInstances(response, &metadata)
}
- output := &DescribeFpgaImageAttributeOutput{}
+ output := &DescribeFleetInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -29327,7 +29612,7 @@ func (m *awsEc2query_deserializeOpDescribeFpgaImageAttribute) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFpgaImageAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFleetInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29341,7 +29626,7 @@ func (m *awsEc2query_deserializeOpDescribeFpgaImageAttribute) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFleetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29374,14 +29659,14 @@ func awsEc2query_deserializeOpErrorDescribeFpgaImageAttribute(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeFpgaImages struct {
+type awsEc2query_deserializeOpDescribeFleets struct {
}
-func (*awsEc2query_deserializeOpDescribeFpgaImages) ID() string {
+func (*awsEc2query_deserializeOpDescribeFleets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeFpgaImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29399,9 +29684,9 @@ func (m *awsEc2query_deserializeOpDescribeFpgaImages) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeFpgaImages(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFleets(response, &metadata)
}
- output := &DescribeFpgaImagesOutput{}
+ output := &DescribeFleetsOutput{}
out.Result = output
var buff [1024]byte
@@ -29422,7 +29707,7 @@ func (m *awsEc2query_deserializeOpDescribeFpgaImages) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeFpgaImagesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFleetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29436,7 +29721,7 @@ func (m *awsEc2query_deserializeOpDescribeFpgaImages) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeFpgaImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29469,14 +29754,14 @@ func awsEc2query_deserializeOpErrorDescribeFpgaImages(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpDescribeHostReservationOfferings struct {
+type awsEc2query_deserializeOpDescribeFlowLogs struct {
}
-func (*awsEc2query_deserializeOpDescribeHostReservationOfferings) ID() string {
+func (*awsEc2query_deserializeOpDescribeFlowLogs) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeHostReservationOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFlowLogs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29494,9 +29779,9 @@ func (m *awsEc2query_deserializeOpDescribeHostReservationOfferings) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeHostReservationOfferings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFlowLogs(response, &metadata)
}
- output := &DescribeHostReservationOfferingsOutput{}
+ output := &DescribeFlowLogsOutput{}
out.Result = output
var buff [1024]byte
@@ -29517,7 +29802,7 @@ func (m *awsEc2query_deserializeOpDescribeHostReservationOfferings) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeHostReservationOfferingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFlowLogsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29531,7 +29816,7 @@ func (m *awsEc2query_deserializeOpDescribeHostReservationOfferings) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeHostReservationOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFlowLogs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29564,14 +29849,14 @@ func awsEc2query_deserializeOpErrorDescribeHostReservationOfferings(response *sm
}
}
-type awsEc2query_deserializeOpDescribeHostReservations struct {
+type awsEc2query_deserializeOpDescribeFpgaImageAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeHostReservations) ID() string {
+func (*awsEc2query_deserializeOpDescribeFpgaImageAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeHostReservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29589,9 +29874,9 @@ func (m *awsEc2query_deserializeOpDescribeHostReservations) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeHostReservations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFpgaImageAttribute(response, &metadata)
}
- output := &DescribeHostReservationsOutput{}
+ output := &DescribeFpgaImageAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -29612,7 +29897,7 @@ func (m *awsEc2query_deserializeOpDescribeHostReservations) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeHostReservationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFpgaImageAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29626,7 +29911,7 @@ func (m *awsEc2query_deserializeOpDescribeHostReservations) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeHostReservations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29659,14 +29944,14 @@ func awsEc2query_deserializeOpErrorDescribeHostReservations(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeHosts struct {
+type awsEc2query_deserializeOpDescribeFpgaImages struct {
}
-func (*awsEc2query_deserializeOpDescribeHosts) ID() string {
+func (*awsEc2query_deserializeOpDescribeFpgaImages) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeFpgaImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29684,9 +29969,9 @@ func (m *awsEc2query_deserializeOpDescribeHosts) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeHosts(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeFpgaImages(response, &metadata)
}
- output := &DescribeHostsOutput{}
+ output := &DescribeFpgaImagesOutput{}
out.Result = output
var buff [1024]byte
@@ -29707,7 +29992,7 @@ func (m *awsEc2query_deserializeOpDescribeHosts) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeHostsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeFpgaImagesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29721,7 +30006,7 @@ func (m *awsEc2query_deserializeOpDescribeHosts) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeFpgaImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29754,14 +30039,14 @@ func awsEc2query_deserializeOpErrorDescribeHosts(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations struct {
+type awsEc2query_deserializeOpDescribeHostReservationOfferings struct {
}
-func (*awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeHostReservationOfferings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeHostReservationOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29779,9 +30064,9 @@ func (m *awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) Handle
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIamInstanceProfileAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeHostReservationOfferings(response, &metadata)
}
- output := &DescribeIamInstanceProfileAssociationsOutput{}
+ output := &DescribeHostReservationOfferingsOutput{}
out.Result = output
var buff [1024]byte
@@ -29802,7 +30087,7 @@ func (m *awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) Handle
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIamInstanceProfileAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeHostReservationOfferingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29816,7 +30101,7 @@ func (m *awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) Handle
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIamInstanceProfileAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeHostReservationOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29849,14 +30134,14 @@ func awsEc2query_deserializeOpErrorDescribeIamInstanceProfileAssociations(respon
}
}
-type awsEc2query_deserializeOpDescribeIdentityIdFormat struct {
+type awsEc2query_deserializeOpDescribeHostReservations struct {
}
-func (*awsEc2query_deserializeOpDescribeIdentityIdFormat) ID() string {
+func (*awsEc2query_deserializeOpDescribeHostReservations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIdentityIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeHostReservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29874,9 +30159,9 @@ func (m *awsEc2query_deserializeOpDescribeIdentityIdFormat) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIdentityIdFormat(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeHostReservations(response, &metadata)
}
- output := &DescribeIdentityIdFormatOutput{}
+ output := &DescribeHostReservationsOutput{}
out.Result = output
var buff [1024]byte
@@ -29897,7 +30182,7 @@ func (m *awsEc2query_deserializeOpDescribeIdentityIdFormat) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIdentityIdFormatOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeHostReservationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -29911,7 +30196,7 @@ func (m *awsEc2query_deserializeOpDescribeIdentityIdFormat) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIdentityIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeHostReservations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -29944,14 +30229,14 @@ func awsEc2query_deserializeOpErrorDescribeIdentityIdFormat(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeIdFormat struct {
+type awsEc2query_deserializeOpDescribeHosts struct {
}
-func (*awsEc2query_deserializeOpDescribeIdFormat) ID() string {
+func (*awsEc2query_deserializeOpDescribeHosts) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -29969,9 +30254,9 @@ func (m *awsEc2query_deserializeOpDescribeIdFormat) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIdFormat(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeHosts(response, &metadata)
}
- output := &DescribeIdFormatOutput{}
+ output := &DescribeHostsOutput{}
out.Result = output
var buff [1024]byte
@@ -29992,7 +30277,7 @@ func (m *awsEc2query_deserializeOpDescribeIdFormat) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIdFormatOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeHostsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30006,7 +30291,7 @@ func (m *awsEc2query_deserializeOpDescribeIdFormat) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30039,14 +30324,14 @@ func awsEc2query_deserializeOpErrorDescribeIdFormat(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDescribeImageAttribute struct {
+type awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeImageAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIamInstanceProfileAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30064,9 +30349,9 @@ func (m *awsEc2query_deserializeOpDescribeImageAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImageAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIamInstanceProfileAssociations(response, &metadata)
}
- output := &DescribeImageAttributeOutput{}
+ output := &DescribeIamInstanceProfileAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -30087,7 +30372,7 @@ func (m *awsEc2query_deserializeOpDescribeImageAttribute) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImageAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIamInstanceProfileAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30101,7 +30386,7 @@ func (m *awsEc2query_deserializeOpDescribeImageAttribute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIamInstanceProfileAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30134,14 +30419,14 @@ func awsEc2query_deserializeOpErrorDescribeImageAttribute(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeImageReferences struct {
+type awsEc2query_deserializeOpDescribeIdentityIdFormat struct {
}
-func (*awsEc2query_deserializeOpDescribeImageReferences) ID() string {
+func (*awsEc2query_deserializeOpDescribeIdentityIdFormat) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImageReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIdentityIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30159,9 +30444,9 @@ func (m *awsEc2query_deserializeOpDescribeImageReferences) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImageReferences(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIdentityIdFormat(response, &metadata)
}
- output := &DescribeImageReferencesOutput{}
+ output := &DescribeIdentityIdFormatOutput{}
out.Result = output
var buff [1024]byte
@@ -30182,7 +30467,7 @@ func (m *awsEc2query_deserializeOpDescribeImageReferences) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImageReferencesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIdentityIdFormatOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30196,7 +30481,7 @@ func (m *awsEc2query_deserializeOpDescribeImageReferences) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImageReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIdentityIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30229,14 +30514,14 @@ func awsEc2query_deserializeOpErrorDescribeImageReferences(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeImages struct {
+type awsEc2query_deserializeOpDescribeIdFormat struct {
}
-func (*awsEc2query_deserializeOpDescribeImages) ID() string {
+func (*awsEc2query_deserializeOpDescribeIdFormat) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30254,9 +30539,9 @@ func (m *awsEc2query_deserializeOpDescribeImages) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImages(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIdFormat(response, &metadata)
}
- output := &DescribeImagesOutput{}
+ output := &DescribeIdFormatOutput{}
out.Result = output
var buff [1024]byte
@@ -30277,7 +30562,7 @@ func (m *awsEc2query_deserializeOpDescribeImages) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImagesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIdFormatOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30291,7 +30576,7 @@ func (m *awsEc2query_deserializeOpDescribeImages) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30324,14 +30609,14 @@ func awsEc2query_deserializeOpErrorDescribeImages(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDescribeImageUsageReportEntries struct {
+type awsEc2query_deserializeOpDescribeImageAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeImageUsageReportEntries) ID() string {
+func (*awsEc2query_deserializeOpDescribeImageAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImageUsageReportEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30349,9 +30634,9 @@ func (m *awsEc2query_deserializeOpDescribeImageUsageReportEntries) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImageUsageReportEntries(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImageAttribute(response, &metadata)
}
- output := &DescribeImageUsageReportEntriesOutput{}
+ output := &DescribeImageAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -30372,7 +30657,7 @@ func (m *awsEc2query_deserializeOpDescribeImageUsageReportEntries) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImageUsageReportEntriesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImageAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30386,7 +30671,7 @@ func (m *awsEc2query_deserializeOpDescribeImageUsageReportEntries) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImageUsageReportEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30419,14 +30704,14 @@ func awsEc2query_deserializeOpErrorDescribeImageUsageReportEntries(response *smi
}
}
-type awsEc2query_deserializeOpDescribeImageUsageReports struct {
+type awsEc2query_deserializeOpDescribeImageReferences struct {
}
-func (*awsEc2query_deserializeOpDescribeImageUsageReports) ID() string {
+func (*awsEc2query_deserializeOpDescribeImageReferences) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImageUsageReports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImageReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30444,9 +30729,9 @@ func (m *awsEc2query_deserializeOpDescribeImageUsageReports) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImageUsageReports(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImageReferences(response, &metadata)
}
- output := &DescribeImageUsageReportsOutput{}
+ output := &DescribeImageReferencesOutput{}
out.Result = output
var buff [1024]byte
@@ -30467,7 +30752,7 @@ func (m *awsEc2query_deserializeOpDescribeImageUsageReports) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImageUsageReportsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImageReferencesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30481,7 +30766,7 @@ func (m *awsEc2query_deserializeOpDescribeImageUsageReports) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImageUsageReports(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImageReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30514,14 +30799,14 @@ func awsEc2query_deserializeOpErrorDescribeImageUsageReports(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeImportImageTasks struct {
+type awsEc2query_deserializeOpDescribeImages struct {
}
-func (*awsEc2query_deserializeOpDescribeImportImageTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeImages) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImportImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30539,9 +30824,9 @@ func (m *awsEc2query_deserializeOpDescribeImportImageTasks) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImportImageTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImages(response, &metadata)
}
- output := &DescribeImportImageTasksOutput{}
+ output := &DescribeImagesOutput{}
out.Result = output
var buff [1024]byte
@@ -30562,7 +30847,7 @@ func (m *awsEc2query_deserializeOpDescribeImportImageTasks) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImportImageTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImagesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30576,7 +30861,7 @@ func (m *awsEc2query_deserializeOpDescribeImportImageTasks) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImportImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImages(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30609,14 +30894,14 @@ func awsEc2query_deserializeOpErrorDescribeImportImageTasks(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeImportSnapshotTasks struct {
+type awsEc2query_deserializeOpDescribeImageUsageReportEntries struct {
}
-func (*awsEc2query_deserializeOpDescribeImportSnapshotTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeImageUsageReportEntries) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeImportSnapshotTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImageUsageReportEntries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30634,9 +30919,9 @@ func (m *awsEc2query_deserializeOpDescribeImportSnapshotTasks) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeImportSnapshotTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImageUsageReportEntries(response, &metadata)
}
- output := &DescribeImportSnapshotTasksOutput{}
+ output := &DescribeImageUsageReportEntriesOutput{}
out.Result = output
var buff [1024]byte
@@ -30657,7 +30942,7 @@ func (m *awsEc2query_deserializeOpDescribeImportSnapshotTasks) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeImportSnapshotTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImageUsageReportEntriesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30671,7 +30956,7 @@ func (m *awsEc2query_deserializeOpDescribeImportSnapshotTasks) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeImportSnapshotTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImageUsageReportEntries(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30704,14 +30989,14 @@ func awsEc2query_deserializeOpErrorDescribeImportSnapshotTasks(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeInstanceAttribute struct {
+type awsEc2query_deserializeOpDescribeImageUsageReports struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeImageUsageReports) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImageUsageReports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30729,9 +31014,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceAttribute) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImageUsageReports(response, &metadata)
}
- output := &DescribeInstanceAttributeOutput{}
+ output := &DescribeImageUsageReportsOutput{}
out.Result = output
var buff [1024]byte
@@ -30752,7 +31037,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceAttribute) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImageUsageReportsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30766,7 +31051,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceAttribute) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImageUsageReports(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30799,14 +31084,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceAttribute(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeInstanceConnectEndpoints struct {
+type awsEc2query_deserializeOpDescribeImportImageTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) ID() string {
+func (*awsEc2query_deserializeOpDescribeImportImageTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImportImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30824,9 +31109,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceConnectEndpoints(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImportImageTasks(response, &metadata)
}
- output := &DescribeInstanceConnectEndpointsOutput{}
+ output := &DescribeImportImageTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -30847,7 +31132,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceConnectEndpointsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImportImageTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30861,7 +31146,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceConnectEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImportImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30894,14 +31179,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceConnectEndpoints(response *sm
}
}
-type awsEc2query_deserializeOpDescribeInstanceCreditSpecifications struct {
+type awsEc2query_deserializeOpDescribeImportSnapshotTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) ID() string {
+func (*awsEc2query_deserializeOpDescribeImportSnapshotTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeImportSnapshotTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -30919,9 +31204,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceCreditSpecifications(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeImportSnapshotTasks(response, &metadata)
}
- output := &DescribeInstanceCreditSpecificationsOutput{}
+ output := &DescribeImportSnapshotTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -30942,7 +31227,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceCreditSpecificationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeImportSnapshotTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -30956,7 +31241,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceCreditSpecifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeImportSnapshotTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -30989,14 +31274,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceCreditSpecifications(response
}
}
-type awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes struct {
+type awsEc2query_deserializeOpDescribeInstanceAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31014,9 +31299,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceEventNotificationAttributes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceAttribute(response, &metadata)
}
- output := &DescribeInstanceEventNotificationAttributesOutput{}
+ output := &DescribeInstanceAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -31037,7 +31322,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceEventNotificationAttributesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31051,7 +31336,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceEventNotificationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31084,14 +31369,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceEventNotificationAttributes(r
}
}
-type awsEc2query_deserializeOpDescribeInstanceEventWindows struct {
+type awsEc2query_deserializeOpDescribeInstanceConnectEndpoints struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceEventWindows) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceEventWindows) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceConnectEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31109,9 +31394,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceEventWindows) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceEventWindows(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceConnectEndpoints(response, &metadata)
}
- output := &DescribeInstanceEventWindowsOutput{}
+ output := &DescribeInstanceConnectEndpointsOutput{}
out.Result = output
var buff [1024]byte
@@ -31132,7 +31417,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceEventWindows) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceEventWindowsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceConnectEndpointsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31146,7 +31431,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceEventWindows) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceEventWindows(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceConnectEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31179,14 +31464,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceEventWindows(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeInstanceImageMetadata struct {
+type awsEc2query_deserializeOpDescribeInstanceCreditSpecifications struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceImageMetadata) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceImageMetadata) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceCreditSpecifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31204,9 +31489,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceImageMetadata) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceImageMetadata(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceCreditSpecifications(response, &metadata)
}
- output := &DescribeInstanceImageMetadataOutput{}
+ output := &DescribeInstanceCreditSpecificationsOutput{}
out.Result = output
var buff [1024]byte
@@ -31227,7 +31512,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceImageMetadata) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceImageMetadataOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceCreditSpecificationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31241,7 +31526,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceImageMetadata) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceImageMetadata(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceCreditSpecifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31274,14 +31559,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceImageMetadata(response *smith
}
}
-type awsEc2query_deserializeOpDescribeInstances struct {
+type awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes struct {
}
-func (*awsEc2query_deserializeOpDescribeInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceEventNotificationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31299,9 +31584,9 @@ func (m *awsEc2query_deserializeOpDescribeInstances) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceEventNotificationAttributes(response, &metadata)
}
- output := &DescribeInstancesOutput{}
+ output := &DescribeInstanceEventNotificationAttributesOutput{}
out.Result = output
var buff [1024]byte
@@ -31322,7 +31607,7 @@ func (m *awsEc2query_deserializeOpDescribeInstances) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceEventNotificationAttributesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31336,7 +31621,7 @@ func (m *awsEc2query_deserializeOpDescribeInstances) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceEventNotificationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31369,14 +31654,14 @@ func awsEc2query_deserializeOpErrorDescribeInstances(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates struct {
+type awsEc2query_deserializeOpDescribeInstanceEventWindows struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceEventWindows) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceEventWindows) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31394,9 +31679,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceSqlHaHistoryStates(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceEventWindows(response, &metadata)
}
- output := &DescribeInstanceSqlHaHistoryStatesOutput{}
+ output := &DescribeInstanceEventWindowsOutput{}
out.Result = output
var buff [1024]byte
@@ -31417,7 +31702,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceSqlHaHistoryStatesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceEventWindowsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31431,7 +31716,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceSqlHaHistoryStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceEventWindows(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31464,14 +31749,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceSqlHaHistoryStates(response *
}
}
-type awsEc2query_deserializeOpDescribeInstanceSqlHaStates struct {
+type awsEc2query_deserializeOpDescribeInstanceImageMetadata struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceSqlHaStates) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceImageMetadata) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceImageMetadata) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31489,9 +31774,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaStates) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceSqlHaStates(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceImageMetadata(response, &metadata)
}
- output := &DescribeInstanceSqlHaStatesOutput{}
+ output := &DescribeInstanceImageMetadataOutput{}
out.Result = output
var buff [1024]byte
@@ -31512,7 +31797,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaStates) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceSqlHaStatesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceImageMetadataOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31526,7 +31811,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaStates) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceSqlHaStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceImageMetadata(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31559,14 +31844,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceSqlHaStates(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeInstanceStatus struct {
+type awsEc2query_deserializeOpDescribeInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceStatus) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31584,9 +31869,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceStatus) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceStatus(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstances(response, &metadata)
}
- output := &DescribeInstanceStatusOutput{}
+ output := &DescribeInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -31607,7 +31892,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceStatus) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceStatusOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31621,7 +31906,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceStatus) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31654,14 +31939,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceStatus(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeInstanceTopology struct {
+type awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceTopology) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceTopology) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaHistoryStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31679,9 +31964,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTopology) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceTopology(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceSqlHaHistoryStates(response, &metadata)
}
- output := &DescribeInstanceTopologyOutput{}
+ output := &DescribeInstanceSqlHaHistoryStatesOutput{}
out.Result = output
var buff [1024]byte
@@ -31702,7 +31987,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTopology) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceTopologyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceSqlHaHistoryStatesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31716,7 +32001,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTopology) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceTopology(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceSqlHaHistoryStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31749,14 +32034,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceTopology(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeInstanceTypeOfferings struct {
+type awsEc2query_deserializeOpDescribeInstanceSqlHaStates struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceTypeOfferings) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceSqlHaStates) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceTypeOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceSqlHaStates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31774,9 +32059,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTypeOfferings) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceTypeOfferings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceSqlHaStates(response, &metadata)
}
- output := &DescribeInstanceTypeOfferingsOutput{}
+ output := &DescribeInstanceSqlHaStatesOutput{}
out.Result = output
var buff [1024]byte
@@ -31797,7 +32082,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTypeOfferings) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceTypeOfferingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceSqlHaStatesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31811,7 +32096,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTypeOfferings) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceTypeOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceSqlHaStates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31844,14 +32129,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceTypeOfferings(response *smith
}
}
-type awsEc2query_deserializeOpDescribeInstanceTypes struct {
+type awsEc2query_deserializeOpDescribeInstanceStatus struct {
}
-func (*awsEc2query_deserializeOpDescribeInstanceTypes) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceStatus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInstanceTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31869,9 +32154,9 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTypes) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceTypes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceStatus(response, &metadata)
}
- output := &DescribeInstanceTypesOutput{}
+ output := &DescribeInstanceStatusOutput{}
out.Result = output
var buff [1024]byte
@@ -31892,7 +32177,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTypes) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInstanceTypesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceStatusOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -31906,7 +32191,7 @@ func (m *awsEc2query_deserializeOpDescribeInstanceTypes) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInstanceTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -31939,14 +32224,14 @@ func awsEc2query_deserializeOpErrorDescribeInstanceTypes(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpDescribeInternetGateways struct {
+type awsEc2query_deserializeOpDescribeInstanceTopology struct {
}
-func (*awsEc2query_deserializeOpDescribeInternetGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceTopology) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeInternetGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceTopology) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -31964,9 +32249,9 @@ func (m *awsEc2query_deserializeOpDescribeInternetGateways) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeInternetGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceTopology(response, &metadata)
}
- output := &DescribeInternetGatewaysOutput{}
+ output := &DescribeInstanceTopologyOutput{}
out.Result = output
var buff [1024]byte
@@ -31987,7 +32272,7 @@ func (m *awsEc2query_deserializeOpDescribeInternetGateways) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeInternetGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceTopologyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32001,7 +32286,7 @@ func (m *awsEc2query_deserializeOpDescribeInternetGateways) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeInternetGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceTopology(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32034,14 +32319,14 @@ func awsEc2query_deserializeOpErrorDescribeInternetGateways(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeIpamByoasn struct {
+type awsEc2query_deserializeOpDescribeInstanceTypeOfferings struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamByoasn) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceTypeOfferings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceTypeOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32059,9 +32344,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamByoasn) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamByoasn(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceTypeOfferings(response, &metadata)
}
- output := &DescribeIpamByoasnOutput{}
+ output := &DescribeInstanceTypeOfferingsOutput{}
out.Result = output
var buff [1024]byte
@@ -32082,7 +32367,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamByoasn) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamByoasnOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceTypeOfferingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32096,7 +32381,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamByoasn) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceTypeOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32129,14 +32414,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamByoasn(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens struct {
+type awsEc2query_deserializeOpDescribeInstanceTypes struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens) ID() string {
+func (*awsEc2query_deserializeOpDescribeInstanceTypes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInstanceTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32154,9 +32439,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamExternalResourceVerificationTokens(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInstanceTypes(response, &metadata)
}
- output := &DescribeIpamExternalResourceVerificationTokensOutput{}
+ output := &DescribeInstanceTypesOutput{}
out.Result = output
var buff [1024]byte
@@ -32177,7 +32462,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamExternalResourceVerificationTokensOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInstanceTypesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32191,7 +32476,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamExternalResourceVerificationTokens(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInstanceTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32224,14 +32509,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamExternalResourceVerificationToken
}
}
-type awsEc2query_deserializeOpDescribeIpamPolicies struct {
+type awsEc2query_deserializeOpDescribeInternetGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamPolicies) ID() string {
+func (*awsEc2query_deserializeOpDescribeInternetGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeInternetGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32249,9 +32534,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamPolicies) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPolicies(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeInternetGateways(response, &metadata)
}
- output := &DescribeIpamPoliciesOutput{}
+ output := &DescribeInternetGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -32272,7 +32557,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPolicies) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamPoliciesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeInternetGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32286,7 +32571,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPolicies) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeInternetGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32319,14 +32604,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamPolicies(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDescribeIpamPoolAllocations struct {
+type awsEc2query_deserializeOpDescribeIpamByoasn struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamPoolAllocations) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamByoasn) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamPoolAllocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32344,9 +32629,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamPoolAllocations) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPoolAllocations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamByoasn(response, &metadata)
}
- output := &DescribeIpamPoolAllocationsOutput{}
+ output := &DescribeIpamByoasnOutput{}
out.Result = output
var buff [1024]byte
@@ -32367,7 +32652,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPoolAllocations) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamPoolAllocationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamByoasnOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32381,7 +32666,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPoolAllocations) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamPoolAllocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32414,14 +32699,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamPoolAllocations(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeIpamPools struct {
+type awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamPools) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamPools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamExternalResourceVerificationTokens) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32439,9 +32724,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamPools) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPools(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamExternalResourceVerificationTokens(response, &metadata)
}
- output := &DescribeIpamPoolsOutput{}
+ output := &DescribeIpamExternalResourceVerificationTokensOutput{}
out.Result = output
var buff [1024]byte
@@ -32462,7 +32747,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPools) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamPoolsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamExternalResourceVerificationTokensOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32476,7 +32761,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPools) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamPools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamExternalResourceVerificationTokens(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32509,14 +32794,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamPools(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDescribeIpamPrefixListResolvers struct {
+type awsEc2query_deserializeOpDescribeIpamPolicies struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamPolicies) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32534,9 +32819,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolvers(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPolicies(response, &metadata)
}
- output := &DescribeIpamPrefixListResolversOutput{}
+ output := &DescribeIpamPoliciesOutput{}
out.Result = output
var buff [1024]byte
@@ -32557,7 +32842,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamPrefixListResolversOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamPoliciesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32571,7 +32856,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolvers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32604,14 +32889,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolvers(response *smi
}
}
-type awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets struct {
+type awsEc2query_deserializeOpDescribeIpamPoolAllocations struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamPoolAllocations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamPoolAllocations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32629,9 +32914,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolverTargets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPoolAllocations(response, &metadata)
}
- output := &DescribeIpamPrefixListResolverTargetsOutput{}
+ output := &DescribeIpamPoolAllocationsOutput{}
out.Result = output
var buff [1024]byte
@@ -32652,7 +32937,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamPrefixListResolverTargetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamPoolAllocationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32666,7 +32951,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolverTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamPoolAllocations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32699,14 +32984,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolverTargets(respons
}
}
-type awsEc2query_deserializeOpDescribeIpamResourceDiscoveries struct {
+type awsEc2query_deserializeOpDescribeIpamPools struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamPools) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamPools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32724,9 +33009,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPools(response, &metadata)
}
- output := &DescribeIpamResourceDiscoveriesOutput{}
+ output := &DescribeIpamPoolsOutput{}
out.Result = output
var buff [1024]byte
@@ -32747,7 +33032,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveriesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamPoolsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32761,7 +33046,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamPools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32794,14 +33079,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response *smi
}
}
-type awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations struct {
+type awsEc2query_deserializeOpDescribeIpamPrefixListResolvers struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolvers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32819,9 +33104,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) Han
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolvers(response, &metadata)
}
- output := &DescribeIpamResourceDiscoveryAssociationsOutput{}
+ output := &DescribeIpamPrefixListResolversOutput{}
out.Result = output
var buff [1024]byte
@@ -32842,7 +33127,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) Han
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveryAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamPrefixListResolversOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32856,7 +33141,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) Han
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolvers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32889,14 +33174,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(res
}
}
-type awsEc2query_deserializeOpDescribeIpams struct {
+type awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets struct {
}
-func (*awsEc2query_deserializeOpDescribeIpams) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamPrefixListResolverTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -32914,9 +33199,9 @@ func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpams(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolverTargets(response, &metadata)
}
- output := &DescribeIpamsOutput{}
+ output := &DescribeIpamPrefixListResolverTargetsOutput{}
out.Result = output
var buff [1024]byte
@@ -32937,7 +33222,7 @@ func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamPrefixListResolverTargetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -32951,7 +33236,7 @@ func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpams(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamPrefixListResolverTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -32984,14 +33269,14 @@ func awsEc2query_deserializeOpErrorDescribeIpams(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpDescribeIpamScopes struct {
+type awsEc2query_deserializeOpDescribeIpamResourceDiscoveries struct {
}
-func (*awsEc2query_deserializeOpDescribeIpamScopes) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpamScopes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveries) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33009,9 +33294,9 @@ func (m *awsEc2query_deserializeOpDescribeIpamScopes) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamScopes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response, &metadata)
}
- output := &DescribeIpamScopesOutput{}
+ output := &DescribeIpamResourceDiscoveriesOutput{}
out.Result = output
var buff [1024]byte
@@ -33032,7 +33317,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamScopes) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpamScopesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveriesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33046,7 +33331,7 @@ func (m *awsEc2query_deserializeOpDescribeIpamScopes) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpamScopes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveries(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33079,14 +33364,14 @@ func awsEc2query_deserializeOpErrorDescribeIpamScopes(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpDescribeIpv6Pools struct {
+type awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeIpv6Pools) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeIpv6Pools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamResourceDiscoveryAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33104,9 +33389,9 @@ func (m *awsEc2query_deserializeOpDescribeIpv6Pools) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeIpv6Pools(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(response, &metadata)
}
- output := &DescribeIpv6PoolsOutput{}
+ output := &DescribeIpamResourceDiscoveryAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -33127,7 +33412,7 @@ func (m *awsEc2query_deserializeOpDescribeIpv6Pools) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeIpv6PoolsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamResourceDiscoveryAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33141,7 +33426,7 @@ func (m *awsEc2query_deserializeOpDescribeIpv6Pools) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeIpv6Pools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamResourceDiscoveryAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33174,14 +33459,14 @@ func awsEc2query_deserializeOpErrorDescribeIpv6Pools(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDescribeKeyPairs struct {
+type awsEc2query_deserializeOpDescribeIpams struct {
}
-func (*awsEc2query_deserializeOpDescribeKeyPairs) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpams) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeKeyPairs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpams) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33199,9 +33484,9 @@ func (m *awsEc2query_deserializeOpDescribeKeyPairs) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeKeyPairs(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpams(response, &metadata)
}
- output := &DescribeKeyPairsOutput{}
+ output := &DescribeIpamsOutput{}
out.Result = output
var buff [1024]byte
@@ -33222,7 +33507,7 @@ func (m *awsEc2query_deserializeOpDescribeKeyPairs) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeKeyPairsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33236,7 +33521,7 @@ func (m *awsEc2query_deserializeOpDescribeKeyPairs) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeKeyPairs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpams(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33269,14 +33554,14 @@ func awsEc2query_deserializeOpErrorDescribeKeyPairs(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDescribeLaunchTemplates struct {
+type awsEc2query_deserializeOpDescribeIpamScopes struct {
}
-func (*awsEc2query_deserializeOpDescribeLaunchTemplates) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpamScopes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLaunchTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpamScopes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33294,9 +33579,9 @@ func (m *awsEc2query_deserializeOpDescribeLaunchTemplates) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLaunchTemplates(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpamScopes(response, &metadata)
}
- output := &DescribeLaunchTemplatesOutput{}
+ output := &DescribeIpamScopesOutput{}
out.Result = output
var buff [1024]byte
@@ -33317,7 +33602,7 @@ func (m *awsEc2query_deserializeOpDescribeLaunchTemplates) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLaunchTemplatesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpamScopesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33331,7 +33616,7 @@ func (m *awsEc2query_deserializeOpDescribeLaunchTemplates) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLaunchTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpamScopes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33364,14 +33649,14 @@ func awsEc2query_deserializeOpErrorDescribeLaunchTemplates(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeLaunchTemplateVersions struct {
+type awsEc2query_deserializeOpDescribeIpv6Pools struct {
}
-func (*awsEc2query_deserializeOpDescribeLaunchTemplateVersions) ID() string {
+func (*awsEc2query_deserializeOpDescribeIpv6Pools) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLaunchTemplateVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeIpv6Pools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33389,9 +33674,9 @@ func (m *awsEc2query_deserializeOpDescribeLaunchTemplateVersions) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLaunchTemplateVersions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeIpv6Pools(response, &metadata)
}
- output := &DescribeLaunchTemplateVersionsOutput{}
+ output := &DescribeIpv6PoolsOutput{}
out.Result = output
var buff [1024]byte
@@ -33412,7 +33697,7 @@ func (m *awsEc2query_deserializeOpDescribeLaunchTemplateVersions) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLaunchTemplateVersionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeIpv6PoolsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33426,7 +33711,7 @@ func (m *awsEc2query_deserializeOpDescribeLaunchTemplateVersions) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLaunchTemplateVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeIpv6Pools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33459,14 +33744,14 @@ func awsEc2query_deserializeOpErrorDescribeLaunchTemplateVersions(response *smit
}
}
-type awsEc2query_deserializeOpDescribeLocalGatewayRouteTables struct {
+type awsEc2query_deserializeOpDescribeKeyPairs struct {
}
-func (*awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) ID() string {
+func (*awsEc2query_deserializeOpDescribeKeyPairs) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeKeyPairs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33484,9 +33769,9 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTables(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeKeyPairs(response, &metadata)
}
- output := &DescribeLocalGatewayRouteTablesOutput{}
+ output := &DescribeKeyPairsOutput{}
out.Result = output
var buff [1024]byte
@@ -33507,7 +33792,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayRouteTablesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeKeyPairsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33521,7 +33806,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeKeyPairs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33554,14 +33839,14 @@ func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTables(response *smi
}
}
-type awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations struct {
+type awsEc2query_deserializeOpDescribeLaunchTemplates struct {
}
-func (*awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeLaunchTemplates) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLaunchTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33579,9 +33864,9 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterface
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLaunchTemplates(response, &metadata)
}
- output := &DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput{}
+ output := &DescribeLaunchTemplatesOutput{}
out.Result = output
var buff [1024]byte
@@ -33602,7 +33887,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterface
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLaunchTemplatesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33616,7 +33901,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterface
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLaunchTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33649,14 +33934,14 @@ func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVirtualInterfac
}
}
-type awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations struct {
+type awsEc2query_deserializeOpDescribeLaunchTemplateVersions struct {
}
-func (*awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeLaunchTemplateVersions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLaunchTemplateVersions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33674,9 +33959,9 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations)
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVpcAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLaunchTemplateVersions(response, &metadata)
}
- output := &DescribeLocalGatewayRouteTableVpcAssociationsOutput{}
+ output := &DescribeLaunchTemplateVersionsOutput{}
out.Result = output
var buff [1024]byte
@@ -33697,7 +33982,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations)
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayRouteTableVpcAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLaunchTemplateVersionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33711,7 +33996,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations)
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVpcAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLaunchTemplateVersions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33744,14 +34029,14 @@ func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVpcAssociations
}
}
-type awsEc2query_deserializeOpDescribeLocalGateways struct {
+type awsEc2query_deserializeOpDescribeLocalGatewayRouteTables struct {
}
-func (*awsEc2query_deserializeOpDescribeLocalGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLocalGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33769,9 +34054,9 @@ func (m *awsEc2query_deserializeOpDescribeLocalGateways) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTables(response, &metadata)
}
- output := &DescribeLocalGatewaysOutput{}
+ output := &DescribeLocalGatewayRouteTablesOutput{}
out.Result = output
var buff [1024]byte
@@ -33792,7 +34077,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGateways) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLocalGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayRouteTablesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33806,7 +34091,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGateways) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLocalGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33839,14 +34124,14 @@ func awsEc2query_deserializeOpErrorDescribeLocalGateways(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups struct {
+type awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) ID() string {
+func (*awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33864,9 +34149,9 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaceGroups(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(response, &metadata)
}
- output := &DescribeLocalGatewayVirtualInterfaceGroupsOutput{}
+ output := &DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -33887,7 +34172,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayVirtualInterfaceGroupsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33901,7 +34186,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaceGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -33934,14 +34219,14 @@ func awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaceGroups(re
}
}
-type awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces struct {
+type awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) ID() string {
+func (*awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLocalGatewayRouteTableVpcAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -33959,9 +34244,9 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaces(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVpcAssociations(response, &metadata)
}
- output := &DescribeLocalGatewayVirtualInterfacesOutput{}
+ output := &DescribeLocalGatewayRouteTableVpcAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -33982,7 +34267,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayVirtualInterfacesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayRouteTableVpcAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -33996,7 +34281,7 @@ func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLocalGatewayRouteTableVpcAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34029,14 +34314,14 @@ func awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaces(respons
}
}
-type awsEc2query_deserializeOpDescribeLockedSnapshots struct {
+type awsEc2query_deserializeOpDescribeLocalGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeLockedSnapshots) ID() string {
+func (*awsEc2query_deserializeOpDescribeLocalGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeLockedSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLocalGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34054,9 +34339,9 @@ func (m *awsEc2query_deserializeOpDescribeLockedSnapshots) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeLockedSnapshots(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGateways(response, &metadata)
}
- output := &DescribeLockedSnapshotsOutput{}
+ output := &DescribeLocalGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -34077,7 +34362,7 @@ func (m *awsEc2query_deserializeOpDescribeLockedSnapshots) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeLockedSnapshotsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLocalGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34091,7 +34376,7 @@ func (m *awsEc2query_deserializeOpDescribeLockedSnapshots) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeLockedSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLocalGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34124,14 +34409,14 @@ func awsEc2query_deserializeOpErrorDescribeLockedSnapshots(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeMacHosts struct {
+type awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups struct {
}
-func (*awsEc2query_deserializeOpDescribeMacHosts) ID() string {
+func (*awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeMacHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaceGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34149,9 +34434,9 @@ func (m *awsEc2query_deserializeOpDescribeMacHosts) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeMacHosts(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaceGroups(response, &metadata)
}
- output := &DescribeMacHostsOutput{}
+ output := &DescribeLocalGatewayVirtualInterfaceGroupsOutput{}
out.Result = output
var buff [1024]byte
@@ -34172,7 +34457,7 @@ func (m *awsEc2query_deserializeOpDescribeMacHosts) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeMacHostsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayVirtualInterfaceGroupsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34186,7 +34471,7 @@ func (m *awsEc2query_deserializeOpDescribeMacHosts) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeMacHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaceGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34219,14 +34504,14 @@ func awsEc2query_deserializeOpErrorDescribeMacHosts(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDescribeMacModificationTasks struct {
+type awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces struct {
}
-func (*awsEc2query_deserializeOpDescribeMacModificationTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeMacModificationTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLocalGatewayVirtualInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34244,9 +34529,9 @@ func (m *awsEc2query_deserializeOpDescribeMacModificationTasks) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeMacModificationTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaces(response, &metadata)
}
- output := &DescribeMacModificationTasksOutput{}
+ output := &DescribeLocalGatewayVirtualInterfacesOutput{}
out.Result = output
var buff [1024]byte
@@ -34267,7 +34552,7 @@ func (m *awsEc2query_deserializeOpDescribeMacModificationTasks) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeMacModificationTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLocalGatewayVirtualInterfacesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34281,7 +34566,7 @@ func (m *awsEc2query_deserializeOpDescribeMacModificationTasks) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeMacModificationTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLocalGatewayVirtualInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34314,14 +34599,14 @@ func awsEc2query_deserializeOpErrorDescribeMacModificationTasks(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeManagedPrefixLists struct {
+type awsEc2query_deserializeOpDescribeLockedSnapshots struct {
}
-func (*awsEc2query_deserializeOpDescribeManagedPrefixLists) ID() string {
+func (*awsEc2query_deserializeOpDescribeLockedSnapshots) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeManagedPrefixLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeLockedSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34339,9 +34624,9 @@ func (m *awsEc2query_deserializeOpDescribeManagedPrefixLists) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeManagedPrefixLists(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeLockedSnapshots(response, &metadata)
}
- output := &DescribeManagedPrefixListsOutput{}
+ output := &DescribeLockedSnapshotsOutput{}
out.Result = output
var buff [1024]byte
@@ -34362,7 +34647,7 @@ func (m *awsEc2query_deserializeOpDescribeManagedPrefixLists) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeManagedPrefixListsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeLockedSnapshotsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34376,7 +34661,7 @@ func (m *awsEc2query_deserializeOpDescribeManagedPrefixLists) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeManagedPrefixLists(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeLockedSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34409,14 +34694,14 @@ func awsEc2query_deserializeOpErrorDescribeManagedPrefixLists(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeMovingAddresses struct {
+type awsEc2query_deserializeOpDescribeMacHosts struct {
}
-func (*awsEc2query_deserializeOpDescribeMovingAddresses) ID() string {
+func (*awsEc2query_deserializeOpDescribeMacHosts) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeMovingAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeMacHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34434,9 +34719,9 @@ func (m *awsEc2query_deserializeOpDescribeMovingAddresses) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeMovingAddresses(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeMacHosts(response, &metadata)
}
- output := &DescribeMovingAddressesOutput{}
+ output := &DescribeMacHostsOutput{}
out.Result = output
var buff [1024]byte
@@ -34457,7 +34742,7 @@ func (m *awsEc2query_deserializeOpDescribeMovingAddresses) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeMovingAddressesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeMacHostsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34471,7 +34756,7 @@ func (m *awsEc2query_deserializeOpDescribeMovingAddresses) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeMovingAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeMacHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34504,14 +34789,14 @@ func awsEc2query_deserializeOpErrorDescribeMovingAddresses(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeNatGateways struct {
+type awsEc2query_deserializeOpDescribeMacModificationTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeNatGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeMacModificationTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNatGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeMacModificationTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34529,9 +34814,9 @@ func (m *awsEc2query_deserializeOpDescribeNatGateways) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNatGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeMacModificationTasks(response, &metadata)
}
- output := &DescribeNatGatewaysOutput{}
+ output := &DescribeMacModificationTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -34552,7 +34837,7 @@ func (m *awsEc2query_deserializeOpDescribeNatGateways) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNatGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeMacModificationTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34566,7 +34851,7 @@ func (m *awsEc2query_deserializeOpDescribeNatGateways) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNatGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeMacModificationTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34599,14 +34884,14 @@ func awsEc2query_deserializeOpErrorDescribeNatGateways(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeNetworkAcls struct {
+type awsEc2query_deserializeOpDescribeManagedPrefixLists struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkAcls) ID() string {
+func (*awsEc2query_deserializeOpDescribeManagedPrefixLists) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkAcls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeManagedPrefixLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34624,9 +34909,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkAcls) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkAcls(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeManagedPrefixLists(response, &metadata)
}
- output := &DescribeNetworkAclsOutput{}
+ output := &DescribeManagedPrefixListsOutput{}
out.Result = output
var buff [1024]byte
@@ -34647,7 +34932,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkAcls) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkAclsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeManagedPrefixListsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34661,7 +34946,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkAcls) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkAcls(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeManagedPrefixLists(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34694,14 +34979,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkAcls(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses struct {
+type awsEc2query_deserializeOpDescribeMovingAddresses struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) ID() string {
+func (*awsEc2query_deserializeOpDescribeMovingAddresses) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeMovingAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34719,9 +35004,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopeAnalyses(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeMovingAddresses(response, &metadata)
}
- output := &DescribeNetworkInsightsAccessScopeAnalysesOutput{}
+ output := &DescribeMovingAddressesOutput{}
out.Result = output
var buff [1024]byte
@@ -34742,7 +35027,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsAccessScopeAnalysesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeMovingAddressesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34756,7 +35041,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopeAnalyses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeMovingAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34789,14 +35074,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopeAnalyses(re
}
}
-type awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes struct {
+type awsEc2query_deserializeOpDescribeNatGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) ID() string {
+func (*awsEc2query_deserializeOpDescribeNatGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNatGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34814,9 +35099,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNatGateways(response, &metadata)
}
- output := &DescribeNetworkInsightsAccessScopesOutput{}
+ output := &DescribeNatGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -34837,7 +35122,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsAccessScopesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNatGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34851,7 +35136,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNatGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34884,14 +35169,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopes(response
}
}
-type awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses struct {
+type awsEc2query_deserializeOpDescribeNetworkAcls struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkAcls) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkAcls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -34909,9 +35194,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsAnalyses(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkAcls(response, &metadata)
}
- output := &DescribeNetworkInsightsAnalysesOutput{}
+ output := &DescribeNetworkAclsOutput{}
out.Result = output
var buff [1024]byte
@@ -34932,7 +35217,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsAnalysesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkAclsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -34946,7 +35231,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAnalyses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkAcls(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -34979,14 +35264,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAnalyses(response *smi
}
}
-type awsEc2query_deserializeOpDescribeNetworkInsightsPaths struct {
+type awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInsightsPaths) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInsightsPaths) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopeAnalyses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35004,9 +35289,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsPaths) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsPaths(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopeAnalyses(response, &metadata)
}
- output := &DescribeNetworkInsightsPathsOutput{}
+ output := &DescribeNetworkInsightsAccessScopeAnalysesOutput{}
out.Result = output
var buff [1024]byte
@@ -35027,7 +35312,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsPaths) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsPathsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsAccessScopeAnalysesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35041,7 +35326,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInsightsPaths) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInsightsPaths(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopeAnalyses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35074,14 +35359,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInsightsPaths(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute struct {
+type awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAccessScopes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35099,9 +35384,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInterfaceAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopes(response, &metadata)
}
- output := &DescribeNetworkInterfaceAttributeOutput{}
+ output := &DescribeNetworkInsightsAccessScopesOutput{}
out.Result = output
var buff [1024]byte
@@ -35122,7 +35407,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInterfaceAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsAccessScopesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35136,7 +35421,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAccessScopes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35169,14 +35454,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInterfaceAttribute(response *s
}
}
-type awsEc2query_deserializeOpDescribeNetworkInterfacePermissions struct {
+type awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInsightsAnalyses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35194,9 +35479,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInterfacePermissions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsAnalyses(response, &metadata)
}
- output := &DescribeNetworkInterfacePermissionsOutput{}
+ output := &DescribeNetworkInsightsAnalysesOutput{}
out.Result = output
var buff [1024]byte
@@ -35217,7 +35502,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInterfacePermissionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsAnalysesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35231,7 +35516,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInterfacePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInsightsAnalyses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35264,14 +35549,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInterfacePermissions(response
}
}
-type awsEc2query_deserializeOpDescribeNetworkInterfaces struct {
+type awsEc2query_deserializeOpDescribeNetworkInsightsPaths struct {
}
-func (*awsEc2query_deserializeOpDescribeNetworkInterfaces) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInsightsPaths) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeNetworkInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInsightsPaths) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35289,9 +35574,9 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfaces) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInterfaces(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInsightsPaths(response, &metadata)
}
- output := &DescribeNetworkInterfacesOutput{}
+ output := &DescribeNetworkInsightsPathsOutput{}
out.Result = output
var buff [1024]byte
@@ -35312,7 +35597,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfaces) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeNetworkInterfacesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInsightsPathsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35326,7 +35611,7 @@ func (m *awsEc2query_deserializeOpDescribeNetworkInterfaces) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeNetworkInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInsightsPaths(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35359,14 +35644,14 @@ func awsEc2query_deserializeOpErrorDescribeNetworkInterfaces(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeOutpostLags struct {
+type awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeOutpostLags) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeOutpostLags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35384,9 +35669,9 @@ func (m *awsEc2query_deserializeOpDescribeOutpostLags) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeOutpostLags(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInterfaceAttribute(response, &metadata)
}
- output := &DescribeOutpostLagsOutput{}
+ output := &DescribeNetworkInterfaceAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -35407,7 +35692,7 @@ func (m *awsEc2query_deserializeOpDescribeOutpostLags) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeOutpostLagsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInterfaceAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35421,7 +35706,7 @@ func (m *awsEc2query_deserializeOpDescribeOutpostLags) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeOutpostLags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35454,14 +35739,14 @@ func awsEc2query_deserializeOpErrorDescribeOutpostLags(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribePlacementGroups struct {
+type awsEc2query_deserializeOpDescribeNetworkInterfacePermissions struct {
}
-func (*awsEc2query_deserializeOpDescribePlacementGroups) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribePlacementGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInterfacePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35479,9 +35764,9 @@ func (m *awsEc2query_deserializeOpDescribePlacementGroups) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribePlacementGroups(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInterfacePermissions(response, &metadata)
}
- output := &DescribePlacementGroupsOutput{}
+ output := &DescribeNetworkInterfacePermissionsOutput{}
out.Result = output
var buff [1024]byte
@@ -35502,7 +35787,7 @@ func (m *awsEc2query_deserializeOpDescribePlacementGroups) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribePlacementGroupsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInterfacePermissionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35516,7 +35801,7 @@ func (m *awsEc2query_deserializeOpDescribePlacementGroups) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribePlacementGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInterfacePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35549,14 +35834,14 @@ func awsEc2query_deserializeOpErrorDescribePlacementGroups(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribePrefixLists struct {
+type awsEc2query_deserializeOpDescribeNetworkInterfaces struct {
}
-func (*awsEc2query_deserializeOpDescribePrefixLists) ID() string {
+func (*awsEc2query_deserializeOpDescribeNetworkInterfaces) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribePrefixLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeNetworkInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35574,9 +35859,9 @@ func (m *awsEc2query_deserializeOpDescribePrefixLists) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribePrefixLists(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeNetworkInterfaces(response, &metadata)
}
- output := &DescribePrefixListsOutput{}
+ output := &DescribeNetworkInterfacesOutput{}
out.Result = output
var buff [1024]byte
@@ -35597,7 +35882,7 @@ func (m *awsEc2query_deserializeOpDescribePrefixLists) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribePrefixListsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeNetworkInterfacesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35611,7 +35896,7 @@ func (m *awsEc2query_deserializeOpDescribePrefixLists) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribePrefixLists(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeNetworkInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35644,14 +35929,14 @@ func awsEc2query_deserializeOpErrorDescribePrefixLists(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribePrincipalIdFormat struct {
+type awsEc2query_deserializeOpDescribeOutpostLags struct {
}
-func (*awsEc2query_deserializeOpDescribePrincipalIdFormat) ID() string {
+func (*awsEc2query_deserializeOpDescribeOutpostLags) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribePrincipalIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeOutpostLags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35669,9 +35954,9 @@ func (m *awsEc2query_deserializeOpDescribePrincipalIdFormat) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribePrincipalIdFormat(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeOutpostLags(response, &metadata)
}
- output := &DescribePrincipalIdFormatOutput{}
+ output := &DescribeOutpostLagsOutput{}
out.Result = output
var buff [1024]byte
@@ -35692,7 +35977,7 @@ func (m *awsEc2query_deserializeOpDescribePrincipalIdFormat) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribePrincipalIdFormatOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeOutpostLagsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35706,7 +35991,7 @@ func (m *awsEc2query_deserializeOpDescribePrincipalIdFormat) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribePrincipalIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeOutpostLags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35739,14 +36024,14 @@ func awsEc2query_deserializeOpErrorDescribePrincipalIdFormat(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribePublicIpv4Pools struct {
+type awsEc2query_deserializeOpDescribePlacementGroups struct {
}
-func (*awsEc2query_deserializeOpDescribePublicIpv4Pools) ID() string {
+func (*awsEc2query_deserializeOpDescribePlacementGroups) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribePublicIpv4Pools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribePlacementGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35764,9 +36049,9 @@ func (m *awsEc2query_deserializeOpDescribePublicIpv4Pools) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribePublicIpv4Pools(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribePlacementGroups(response, &metadata)
}
- output := &DescribePublicIpv4PoolsOutput{}
+ output := &DescribePlacementGroupsOutput{}
out.Result = output
var buff [1024]byte
@@ -35787,7 +36072,7 @@ func (m *awsEc2query_deserializeOpDescribePublicIpv4Pools) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribePublicIpv4PoolsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribePlacementGroupsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35801,7 +36086,7 @@ func (m *awsEc2query_deserializeOpDescribePublicIpv4Pools) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribePublicIpv4Pools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribePlacementGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35834,14 +36119,14 @@ func awsEc2query_deserializeOpErrorDescribePublicIpv4Pools(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeRegions struct {
+type awsEc2query_deserializeOpDescribePrefixLists struct {
}
-func (*awsEc2query_deserializeOpDescribeRegions) ID() string {
+func (*awsEc2query_deserializeOpDescribePrefixLists) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeRegions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribePrefixLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35859,9 +36144,9 @@ func (m *awsEc2query_deserializeOpDescribeRegions) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeRegions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribePrefixLists(response, &metadata)
}
- output := &DescribeRegionsOutput{}
+ output := &DescribePrefixListsOutput{}
out.Result = output
var buff [1024]byte
@@ -35882,7 +36167,7 @@ func (m *awsEc2query_deserializeOpDescribeRegions) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeRegionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribePrefixListsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35896,7 +36181,7 @@ func (m *awsEc2query_deserializeOpDescribeRegions) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeRegions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribePrefixLists(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -35929,14 +36214,14 @@ func awsEc2query_deserializeOpErrorDescribeRegions(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks struct {
+type awsEc2query_deserializeOpDescribePrincipalIdFormat struct {
}
-func (*awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribePrincipalIdFormat) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribePrincipalIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -35954,9 +36239,9 @@ func (m *awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeReplaceRootVolumeTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribePrincipalIdFormat(response, &metadata)
}
- output := &DescribeReplaceRootVolumeTasksOutput{}
+ output := &DescribePrincipalIdFormatOutput{}
out.Result = output
var buff [1024]byte
@@ -35977,7 +36262,7 @@ func (m *awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeReplaceRootVolumeTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribePrincipalIdFormatOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -35991,7 +36276,7 @@ func (m *awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeReplaceRootVolumeTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribePrincipalIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36024,14 +36309,14 @@ func awsEc2query_deserializeOpErrorDescribeReplaceRootVolumeTasks(response *smit
}
}
-type awsEc2query_deserializeOpDescribeReservedInstances struct {
+type awsEc2query_deserializeOpDescribePublicIpv4Pools struct {
}
-func (*awsEc2query_deserializeOpDescribeReservedInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribePublicIpv4Pools) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeReservedInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribePublicIpv4Pools) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36049,9 +36334,9 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstances) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribePublicIpv4Pools(response, &metadata)
}
- output := &DescribeReservedInstancesOutput{}
+ output := &DescribePublicIpv4PoolsOutput{}
out.Result = output
var buff [1024]byte
@@ -36072,7 +36357,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstances) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribePublicIpv4PoolsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36086,7 +36371,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstances) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeReservedInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribePublicIpv4Pools(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36119,14 +36404,14 @@ func awsEc2query_deserializeOpErrorDescribeReservedInstances(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeReservedInstancesListings struct {
+type awsEc2query_deserializeOpDescribeRegions struct {
}
-func (*awsEc2query_deserializeOpDescribeReservedInstancesListings) ID() string {
+func (*awsEc2query_deserializeOpDescribeRegions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeReservedInstancesListings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeRegions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36144,9 +36429,9 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesListings) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstancesListings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeRegions(response, &metadata)
}
- output := &DescribeReservedInstancesListingsOutput{}
+ output := &DescribeRegionsOutput{}
out.Result = output
var buff [1024]byte
@@ -36167,7 +36452,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesListings) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesListingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeRegionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36181,7 +36466,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesListings) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeReservedInstancesListings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeRegions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36214,14 +36499,14 @@ func awsEc2query_deserializeOpErrorDescribeReservedInstancesListings(response *s
}
}
-type awsEc2query_deserializeOpDescribeReservedInstancesModifications struct {
+type awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeReservedInstancesModifications) ID() string {
+func (*awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeReservedInstancesModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeReplaceRootVolumeTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36239,9 +36524,9 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesModifications) Handle
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstancesModifications(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeReplaceRootVolumeTasks(response, &metadata)
}
- output := &DescribeReservedInstancesModificationsOutput{}
+ output := &DescribeReplaceRootVolumeTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -36262,7 +36547,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesModifications) Handle
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesModificationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeReplaceRootVolumeTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36276,7 +36561,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesModifications) Handle
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeReservedInstancesModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeReplaceRootVolumeTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36309,14 +36594,14 @@ func awsEc2query_deserializeOpErrorDescribeReservedInstancesModifications(respon
}
}
-type awsEc2query_deserializeOpDescribeReservedInstancesOfferings struct {
+type awsEc2query_deserializeOpDescribeReservedInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeReservedInstancesOfferings) ID() string {
+func (*awsEc2query_deserializeOpDescribeReservedInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeReservedInstancesOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeReservedInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36334,9 +36619,9 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesOfferings) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstancesOfferings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstances(response, &metadata)
}
- output := &DescribeReservedInstancesOfferingsOutput{}
+ output := &DescribeReservedInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -36357,7 +36642,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesOfferings) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesOfferingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36371,7 +36656,7 @@ func (m *awsEc2query_deserializeOpDescribeReservedInstancesOfferings) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeReservedInstancesOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeReservedInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36404,14 +36689,14 @@ func awsEc2query_deserializeOpErrorDescribeReservedInstancesOfferings(response *
}
}
-type awsEc2query_deserializeOpDescribeRouteServerEndpoints struct {
+type awsEc2query_deserializeOpDescribeReservedInstancesListings struct {
}
-func (*awsEc2query_deserializeOpDescribeRouteServerEndpoints) ID() string {
+func (*awsEc2query_deserializeOpDescribeReservedInstancesListings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeRouteServerEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeReservedInstancesListings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36429,9 +36714,9 @@ func (m *awsEc2query_deserializeOpDescribeRouteServerEndpoints) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteServerEndpoints(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstancesListings(response, &metadata)
}
- output := &DescribeRouteServerEndpointsOutput{}
+ output := &DescribeReservedInstancesListingsOutput{}
out.Result = output
var buff [1024]byte
@@ -36452,7 +36737,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteServerEndpoints) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeRouteServerEndpointsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesListingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36466,7 +36751,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteServerEndpoints) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeRouteServerEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeReservedInstancesListings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36499,14 +36784,14 @@ func awsEc2query_deserializeOpErrorDescribeRouteServerEndpoints(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeRouteServerPeers struct {
+type awsEc2query_deserializeOpDescribeReservedInstancesModifications struct {
}
-func (*awsEc2query_deserializeOpDescribeRouteServerPeers) ID() string {
+func (*awsEc2query_deserializeOpDescribeReservedInstancesModifications) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeRouteServerPeers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeReservedInstancesModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36524,9 +36809,9 @@ func (m *awsEc2query_deserializeOpDescribeRouteServerPeers) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteServerPeers(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstancesModifications(response, &metadata)
}
- output := &DescribeRouteServerPeersOutput{}
+ output := &DescribeReservedInstancesModificationsOutput{}
out.Result = output
var buff [1024]byte
@@ -36547,7 +36832,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteServerPeers) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeRouteServerPeersOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesModificationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36561,7 +36846,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteServerPeers) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeRouteServerPeers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeReservedInstancesModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36594,14 +36879,14 @@ func awsEc2query_deserializeOpErrorDescribeRouteServerPeers(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeRouteServers struct {
+type awsEc2query_deserializeOpDescribeReservedInstancesOfferings struct {
}
-func (*awsEc2query_deserializeOpDescribeRouteServers) ID() string {
+func (*awsEc2query_deserializeOpDescribeReservedInstancesOfferings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeRouteServers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeReservedInstancesOfferings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36619,9 +36904,9 @@ func (m *awsEc2query_deserializeOpDescribeRouteServers) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteServers(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeReservedInstancesOfferings(response, &metadata)
}
- output := &DescribeRouteServersOutput{}
+ output := &DescribeReservedInstancesOfferingsOutput{}
out.Result = output
var buff [1024]byte
@@ -36642,7 +36927,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteServers) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeRouteServersOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeReservedInstancesOfferingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36656,7 +36941,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteServers) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeRouteServers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeReservedInstancesOfferings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36689,14 +36974,14 @@ func awsEc2query_deserializeOpErrorDescribeRouteServers(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDescribeRouteTables struct {
+type awsEc2query_deserializeOpDescribeRouteServerEndpoints struct {
}
-func (*awsEc2query_deserializeOpDescribeRouteTables) ID() string {
+func (*awsEc2query_deserializeOpDescribeRouteServerEndpoints) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeRouteServerEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36714,9 +36999,9 @@ func (m *awsEc2query_deserializeOpDescribeRouteTables) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteTables(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteServerEndpoints(response, &metadata)
}
- output := &DescribeRouteTablesOutput{}
+ output := &DescribeRouteServerEndpointsOutput{}
out.Result = output
var buff [1024]byte
@@ -36737,7 +37022,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteTables) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeRouteTablesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeRouteServerEndpointsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36751,7 +37036,7 @@ func (m *awsEc2query_deserializeOpDescribeRouteTables) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeRouteServerEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36784,14 +37069,14 @@ func awsEc2query_deserializeOpErrorDescribeRouteTables(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDescribeScheduledInstanceAvailability struct {
+type awsEc2query_deserializeOpDescribeRouteServerPeers struct {
}
-func (*awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) ID() string {
+func (*awsEc2query_deserializeOpDescribeRouteServerPeers) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeRouteServerPeers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36809,9 +37094,9 @@ func (m *awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeScheduledInstanceAvailability(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteServerPeers(response, &metadata)
}
- output := &DescribeScheduledInstanceAvailabilityOutput{}
+ output := &DescribeRouteServerPeersOutput{}
out.Result = output
var buff [1024]byte
@@ -36832,7 +37117,7 @@ func (m *awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeScheduledInstanceAvailabilityOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeRouteServerPeersOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36846,7 +37131,7 @@ func (m *awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeScheduledInstanceAvailability(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeRouteServerPeers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36879,14 +37164,14 @@ func awsEc2query_deserializeOpErrorDescribeScheduledInstanceAvailability(respons
}
}
-type awsEc2query_deserializeOpDescribeScheduledInstances struct {
+type awsEc2query_deserializeOpDescribeRouteServers struct {
}
-func (*awsEc2query_deserializeOpDescribeScheduledInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribeRouteServers) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeRouteServers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36904,9 +37189,9 @@ func (m *awsEc2query_deserializeOpDescribeScheduledInstances) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeScheduledInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteServers(response, &metadata)
}
- output := &DescribeScheduledInstancesOutput{}
+ output := &DescribeRouteServersOutput{}
out.Result = output
var buff [1024]byte
@@ -36927,7 +37212,7 @@ func (m *awsEc2query_deserializeOpDescribeScheduledInstances) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeScheduledInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeRouteServersOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -36941,7 +37226,7 @@ func (m *awsEc2query_deserializeOpDescribeScheduledInstances) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeRouteServers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -36974,14 +37259,14 @@ func awsEc2query_deserializeOpErrorDescribeScheduledInstances(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeSecondaryInterfaces struct {
+type awsEc2query_deserializeOpDescribeRouteTables struct {
}
-func (*awsEc2query_deserializeOpDescribeSecondaryInterfaces) ID() string {
+func (*awsEc2query_deserializeOpDescribeRouteTables) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecondaryInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -36999,9 +37284,9 @@ func (m *awsEc2query_deserializeOpDescribeSecondaryInterfaces) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeRouteTables(response, &metadata)
}
- output := &DescribeSecondaryInterfacesOutput{}
+ output := &DescribeRouteTablesOutput{}
out.Result = output
var buff [1024]byte
@@ -37022,7 +37307,7 @@ func (m *awsEc2query_deserializeOpDescribeSecondaryInterfaces) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecondaryInterfacesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeRouteTablesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37036,7 +37321,7 @@ func (m *awsEc2query_deserializeOpDescribeSecondaryInterfaces) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37069,14 +37354,14 @@ func awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeSecondaryNetworks struct {
+type awsEc2query_deserializeOpDescribeScheduledInstanceAvailability struct {
}
-func (*awsEc2query_deserializeOpDescribeSecondaryNetworks) ID() string {
+func (*awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecondaryNetworks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeScheduledInstanceAvailability) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37094,9 +37379,9 @@ func (m *awsEc2query_deserializeOpDescribeSecondaryNetworks) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeScheduledInstanceAvailability(response, &metadata)
}
- output := &DescribeSecondaryNetworksOutput{}
+ output := &DescribeScheduledInstanceAvailabilityOutput{}
out.Result = output
var buff [1024]byte
@@ -37117,7 +37402,7 @@ func (m *awsEc2query_deserializeOpDescribeSecondaryNetworks) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecondaryNetworksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeScheduledInstanceAvailabilityOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37131,7 +37416,7 @@ func (m *awsEc2query_deserializeOpDescribeSecondaryNetworks) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeScheduledInstanceAvailability(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37164,14 +37449,14 @@ func awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeSecondarySubnets struct {
+type awsEc2query_deserializeOpDescribeScheduledInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeSecondarySubnets) ID() string {
+func (*awsEc2query_deserializeOpDescribeScheduledInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecondarySubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37189,9 +37474,9 @@ func (m *awsEc2query_deserializeOpDescribeSecondarySubnets) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeScheduledInstances(response, &metadata)
}
- output := &DescribeSecondarySubnetsOutput{}
+ output := &DescribeScheduledInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -37212,7 +37497,7 @@ func (m *awsEc2query_deserializeOpDescribeSecondarySubnets) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecondarySubnetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeScheduledInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37226,7 +37511,7 @@ func (m *awsEc2query_deserializeOpDescribeSecondarySubnets) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37259,14 +37544,14 @@ func awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeSecurityGroupReferences struct {
+type awsEc2query_deserializeOpDescribeSecondaryInterfaces struct {
}
-func (*awsEc2query_deserializeOpDescribeSecurityGroupReferences) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecondaryInterfaces) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecondaryInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37284,9 +37569,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response, &metadata)
}
- output := &DescribeSecurityGroupReferencesOutput{}
+ output := &DescribeSecondaryInterfacesOutput{}
out.Result = output
var buff [1024]byte
@@ -37307,7 +37592,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupReferencesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecondaryInterfacesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37321,7 +37606,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecondaryInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37354,14 +37639,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response *smi
}
}
-type awsEc2query_deserializeOpDescribeSecurityGroupRules struct {
+type awsEc2query_deserializeOpDescribeSecondaryNetworks struct {
}
-func (*awsEc2query_deserializeOpDescribeSecurityGroupRules) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecondaryNetworks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecondaryNetworks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37379,9 +37664,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response, &metadata)
}
- output := &DescribeSecurityGroupRulesOutput{}
+ output := &DescribeSecondaryNetworksOutput{}
out.Result = output
var buff [1024]byte
@@ -37402,7 +37687,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupRulesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecondaryNetworksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37416,7 +37701,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecondaryNetworks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37449,14 +37734,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeSecurityGroups struct {
+type awsEc2query_deserializeOpDescribeSecondarySubnets struct {
}
-func (*awsEc2query_deserializeOpDescribeSecurityGroups) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecondarySubnets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecondarySubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37474,9 +37759,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroups(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response, &metadata)
}
- output := &DescribeSecurityGroupsOutput{}
+ output := &DescribeSecondarySubnetsOutput{}
out.Result = output
var buff [1024]byte
@@ -37497,7 +37782,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecondarySubnetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37511,7 +37796,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecondarySubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37544,14 +37829,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroups(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations struct {
+type awsEc2query_deserializeOpDescribeSecurityGroupReferences struct {
}
-func (*awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecurityGroupReferences) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecurityGroupReferences) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37569,9 +37854,9 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response, &metadata)
}
- output := &DescribeSecurityGroupVpcAssociationsOutput{}
+ output := &DescribeSecurityGroupReferencesOutput{}
out.Result = output
var buff [1024]byte
@@ -37592,7 +37877,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupVpcAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupReferencesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37606,7 +37891,7 @@ func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecurityGroupReferences(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37639,14 +37924,14 @@ func awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response
}
}
-type awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces struct {
+type awsEc2query_deserializeOpDescribeSecurityGroupRules struct {
}
-func (*awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecurityGroupRules) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37664,9 +37949,9 @@ func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response, &metadata)
}
- output := &DescribeServiceLinkVirtualInterfacesOutput{}
+ output := &DescribeSecurityGroupRulesOutput{}
out.Result = output
var buff [1024]byte
@@ -37687,7 +37972,7 @@ func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeServiceLinkVirtualInterfacesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupRulesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37701,7 +37986,7 @@ func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37734,14 +38019,14 @@ func awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response
}
}
-type awsEc2query_deserializeOpDescribeSnapshotAttribute struct {
+type awsEc2query_deserializeOpDescribeSecurityGroups struct {
}
-func (*awsEc2query_deserializeOpDescribeSnapshotAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecurityGroups) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37759,9 +38044,9 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroups(response, &metadata)
}
- output := &DescribeSnapshotAttributeOutput{}
+ output := &DescribeSecurityGroupsOutput{}
out.Result = output
var buff [1024]byte
@@ -37782,7 +38067,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSnapshotAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37796,7 +38081,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37829,14 +38114,14 @@ func awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeSnapshots struct {
+type awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeSnapshots) ID() string {
+func (*awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSecurityGroupVpcAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37854,9 +38139,9 @@ func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshots(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response, &metadata)
}
- output := &DescribeSnapshotsOutput{}
+ output := &DescribeSecurityGroupVpcAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -37877,7 +38162,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSnapshotsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSecurityGroupVpcAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37891,7 +38176,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSecurityGroupVpcAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -37924,14 +38209,14 @@ func awsEc2query_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDescribeSnapshotTierStatus struct {
+type awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces struct {
}
-func (*awsEc2query_deserializeOpDescribeSnapshotTierStatus) ID() string {
+func (*awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeServiceLinkVirtualInterfaces) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -37949,9 +38234,9 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response, &metadata)
}
- output := &DescribeSnapshotTierStatusOutput{}
+ output := &DescribeServiceLinkVirtualInterfacesOutput{}
out.Result = output
var buff [1024]byte
@@ -37972,7 +38257,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSnapshotTierStatusOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeServiceLinkVirtualInterfacesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -37986,7 +38271,7 @@ func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeServiceLinkVirtualInterfaces(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38019,14 +38304,14 @@ func awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeSpotDatafeedSubscription struct {
+type awsEc2query_deserializeOpDescribeSnapshotAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) ID() string {
+func (*awsEc2query_deserializeOpDescribeSnapshotAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38044,9 +38329,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response, &metadata)
}
- output := &DescribeSpotDatafeedSubscriptionOutput{}
+ output := &DescribeSnapshotAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -38067,7 +38352,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSpotDatafeedSubscriptionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSnapshotAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38081,7 +38366,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38114,14 +38399,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response *sm
}
}
-type awsEc2query_deserializeOpDescribeSpotFleetInstances struct {
+type awsEc2query_deserializeOpDescribeSnapshots struct {
}
-func (*awsEc2query_deserializeOpDescribeSpotFleetInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribeSnapshots) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSnapshots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38139,9 +38424,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshots(response, &metadata)
}
- output := &DescribeSpotFleetInstancesOutput{}
+ output := &DescribeSnapshotsOutput{}
out.Result = output
var buff [1024]byte
@@ -38162,7 +38447,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSpotFleetInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSnapshotsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38176,7 +38461,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSnapshots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38209,14 +38494,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response *smithyht
}
}
-type awsEc2query_deserializeOpDescribeSpotFleetRequestHistory struct {
+type awsEc2query_deserializeOpDescribeSnapshotTierStatus struct {
}
-func (*awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) ID() string {
+func (*awsEc2query_deserializeOpDescribeSnapshotTierStatus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSnapshotTierStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38234,9 +38519,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response, &metadata)
}
- output := &DescribeSpotFleetRequestHistoryOutput{}
+ output := &DescribeSnapshotTierStatusOutput{}
out.Result = output
var buff [1024]byte
@@ -38257,7 +38542,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestHistoryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSnapshotTierStatusOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38271,7 +38556,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSnapshotTierStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38304,14 +38589,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response *smi
}
}
-type awsEc2query_deserializeOpDescribeSpotFleetRequests struct {
+type awsEc2query_deserializeOpDescribeSpotDatafeedSubscription struct {
}
-func (*awsEc2query_deserializeOpDescribeSpotFleetRequests) ID() string {
+func (*awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSpotDatafeedSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38329,9 +38614,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response, &metadata)
}
- output := &DescribeSpotFleetRequestsOutput{}
+ output := &DescribeSpotDatafeedSubscriptionOutput{}
out.Result = output
var buff [1024]byte
@@ -38352,7 +38637,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSpotDatafeedSubscriptionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38366,7 +38651,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSpotDatafeedSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38399,14 +38684,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response *smithyhtt
}
}
-type awsEc2query_deserializeOpDescribeSpotInstanceRequests struct {
+type awsEc2query_deserializeOpDescribeSpotFleetInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeSpotInstanceRequests) ID() string {
+func (*awsEc2query_deserializeOpDescribeSpotFleetInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSpotFleetInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38424,9 +38709,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response, &metadata)
}
- output := &DescribeSpotInstanceRequestsOutput{}
+ output := &DescribeSpotFleetInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -38447,7 +38732,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSpotInstanceRequestsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSpotFleetInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38461,7 +38746,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSpotFleetInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38494,14 +38779,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeSpotPriceHistory struct {
+type awsEc2query_deserializeOpDescribeSpotFleetRequestHistory struct {
}
-func (*awsEc2query_deserializeOpDescribeSpotPriceHistory) ID() string {
+func (*awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSpotFleetRequestHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38519,9 +38804,9 @@ func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response, &metadata)
}
- output := &DescribeSpotPriceHistoryOutput{}
+ output := &DescribeSpotFleetRequestHistoryOutput{}
out.Result = output
var buff [1024]byte
@@ -38542,7 +38827,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSpotPriceHistoryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestHistoryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38556,7 +38841,7 @@ func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSpotFleetRequestHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38589,14 +38874,14 @@ func awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeStaleSecurityGroups struct {
+type awsEc2query_deserializeOpDescribeSpotFleetRequests struct {
}
-func (*awsEc2query_deserializeOpDescribeStaleSecurityGroups) ID() string {
+func (*awsEc2query_deserializeOpDescribeSpotFleetRequests) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSpotFleetRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38614,9 +38899,9 @@ func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response, &metadata)
}
- output := &DescribeStaleSecurityGroupsOutput{}
+ output := &DescribeSpotFleetRequestsOutput{}
out.Result = output
var buff [1024]byte
@@ -38637,7 +38922,7 @@ func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeStaleSecurityGroupsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSpotFleetRequestsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38651,7 +38936,7 @@ func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSpotFleetRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38684,14 +38969,14 @@ func awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeStoreImageTasks struct {
+type awsEc2query_deserializeOpDescribeSpotInstanceRequests struct {
}
-func (*awsEc2query_deserializeOpDescribeStoreImageTasks) ID() string {
+func (*awsEc2query_deserializeOpDescribeSpotInstanceRequests) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSpotInstanceRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38709,9 +38994,9 @@ func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response, &metadata)
}
- output := &DescribeStoreImageTasksOutput{}
+ output := &DescribeSpotInstanceRequestsOutput{}
out.Result = output
var buff [1024]byte
@@ -38732,7 +39017,7 @@ func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeStoreImageTasksOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSpotInstanceRequestsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38746,7 +39031,7 @@ func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSpotInstanceRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38779,14 +39064,14 @@ func awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeSubnets struct {
+type awsEc2query_deserializeOpDescribeSpotPriceHistory struct {
}
-func (*awsEc2query_deserializeOpDescribeSubnets) ID() string {
+func (*awsEc2query_deserializeOpDescribeSpotPriceHistory) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSpotPriceHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38804,9 +39089,9 @@ func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeSubnets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response, &metadata)
}
- output := &DescribeSubnetsOutput{}
+ output := &DescribeSpotPriceHistoryOutput{}
out.Result = output
var buff [1024]byte
@@ -38827,7 +39112,7 @@ func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeSubnetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSpotPriceHistoryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38841,7 +39126,7 @@ func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeSubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSpotPriceHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38874,14 +39159,14 @@ func awsEc2query_deserializeOpErrorDescribeSubnets(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpDescribeTags struct {
+type awsEc2query_deserializeOpDescribeStaleSecurityGroups struct {
}
-func (*awsEc2query_deserializeOpDescribeTags) ID() string {
+func (*awsEc2query_deserializeOpDescribeStaleSecurityGroups) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeStaleSecurityGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38899,9 +39184,9 @@ func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTags(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response, &metadata)
}
- output := &DescribeTagsOutput{}
+ output := &DescribeStaleSecurityGroupsOutput{}
out.Result = output
var buff [1024]byte
@@ -38922,7 +39207,7 @@ func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTagsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeStaleSecurityGroupsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -38936,7 +39221,7 @@ func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeStaleSecurityGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -38969,14 +39254,14 @@ func awsEc2query_deserializeOpErrorDescribeTags(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules struct {
+type awsEc2query_deserializeOpDescribeStoreImageTasks struct {
}
-func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) ID() string {
+func (*awsEc2query_deserializeOpDescribeStoreImageTasks) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeStoreImageTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -38994,9 +39279,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response, &metadata)
}
- output := &DescribeTrafficMirrorFilterRulesOutput{}
+ output := &DescribeStoreImageTasksOutput{}
out.Result = output
var buff [1024]byte
@@ -39017,7 +39302,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFilterRulesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeStoreImageTasksOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39031,7 +39316,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeStoreImageTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39064,14 +39349,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response *sm
}
}
-type awsEc2query_deserializeOpDescribeTrafficMirrorFilters struct {
+type awsEc2query_deserializeOpDescribeSubnets struct {
}
-func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilters) ID() string {
+func (*awsEc2query_deserializeOpDescribeSubnets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeSubnets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39089,9 +39374,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeSubnets(response, &metadata)
}
- output := &DescribeTrafficMirrorFiltersOutput{}
+ output := &DescribeSubnetsOutput{}
out.Result = output
var buff [1024]byte
@@ -39112,7 +39397,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFiltersOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeSubnetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39126,7 +39411,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeSubnets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39159,14 +39444,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeTrafficMirrorSessions struct {
+type awsEc2query_deserializeOpDescribeTags struct {
}
-func (*awsEc2query_deserializeOpDescribeTrafficMirrorSessions) ID() string {
+func (*awsEc2query_deserializeOpDescribeTags) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39184,9 +39469,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTags(response, &metadata)
}
- output := &DescribeTrafficMirrorSessionsOutput{}
+ output := &DescribeTagsOutput{}
out.Result = output
var buff [1024]byte
@@ -39207,7 +39492,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorSessionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTagsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39221,7 +39506,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTags(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39254,14 +39539,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response *smith
}
}
-type awsEc2query_deserializeOpDescribeTrafficMirrorTargets struct {
+type awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules struct {
}
-func (*awsEc2query_deserializeOpDescribeTrafficMirrorTargets) ID() string {
+func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilterRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39279,9 +39564,9 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response, &metadata)
}
- output := &DescribeTrafficMirrorTargetsOutput{}
+ output := &DescribeTrafficMirrorFilterRulesOutput{}
out.Result = output
var buff [1024]byte
@@ -39302,7 +39587,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorTargetsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFilterRulesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39316,7 +39601,7 @@ func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilterRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39349,14 +39634,14 @@ func awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayAttachments struct {
+type awsEc2query_deserializeOpDescribeTrafficMirrorFilters struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayAttachments) ID() string {
+func (*awsEc2query_deserializeOpDescribeTrafficMirrorFilters) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTrafficMirrorFilters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39374,9 +39659,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response, &metadata)
}
- output := &DescribeTransitGatewayAttachmentsOutput{}
+ output := &DescribeTrafficMirrorFiltersOutput{}
out.Result = output
var buff [1024]byte
@@ -39397,7 +39682,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayAttachmentsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorFiltersOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39411,7 +39696,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTrafficMirrorFilters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39444,14 +39729,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response *s
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers struct {
+type awsEc2query_deserializeOpDescribeTrafficMirrorSessions struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) ID() string {
+func (*awsEc2query_deserializeOpDescribeTrafficMirrorSessions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTrafficMirrorSessions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39469,9 +39754,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response, &metadata)
}
- output := &DescribeTransitGatewayConnectPeersOutput{}
+ output := &DescribeTrafficMirrorSessionsOutput{}
out.Result = output
var buff [1024]byte
@@ -39492,7 +39777,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectPeersOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorSessionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39506,7 +39791,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTrafficMirrorSessions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39539,14 +39824,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response *
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayConnects struct {
+type awsEc2query_deserializeOpDescribeTrafficMirrorTargets struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayConnects) ID() string {
+func (*awsEc2query_deserializeOpDescribeTrafficMirrorTargets) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTrafficMirrorTargets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39564,9 +39849,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response, &metadata)
}
- output := &DescribeTransitGatewayConnectsOutput{}
+ output := &DescribeTrafficMirrorTargetsOutput{}
out.Result = output
var buff [1024]byte
@@ -39587,7 +39872,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTrafficMirrorTargetsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39601,7 +39886,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTrafficMirrorTargets(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39634,14 +39919,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response *smit
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayAttachments struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayAttachments) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39659,9 +39944,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) Handle
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response, &metadata)
}
- output := &DescribeTransitGatewayMeteringPoliciesOutput{}
+ output := &DescribeTransitGatewayAttachmentsOutput{}
out.Result = output
var buff [1024]byte
@@ -39682,7 +39967,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) Handle
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMeteringPoliciesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayAttachmentsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39696,7 +39981,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) Handle
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39729,14 +40014,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(respon
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnectPeers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39754,9 +40039,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) Handle
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response, &metadata)
}
- output := &DescribeTransitGatewayMulticastDomainsOutput{}
+ output := &DescribeTransitGatewayConnectPeersOutput{}
out.Result = output
var buff [1024]byte
@@ -39777,7 +40062,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) Handle
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMulticastDomainsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectPeersOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39791,7 +40076,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) Handle
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnectPeers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39824,14 +40109,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(respon
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayConnects struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayConnects) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayConnects) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39849,9 +40134,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) Hand
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response, &metadata)
}
- output := &DescribeTransitGatewayPeeringAttachmentsOutput{}
+ output := &DescribeTransitGatewayConnectsOutput{}
out.Result = output
var buff [1024]byte
@@ -39872,7 +40157,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) Hand
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPeeringAttachmentsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayConnectsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39886,7 +40171,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) Hand
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayConnects(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -39919,14 +40204,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(resp
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayMeteringPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -39944,9 +40229,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response, &metadata)
}
- output := &DescribeTransitGatewayPolicyTablesOutput{}
+ output := &DescribeTransitGatewayMeteringPoliciesOutput{}
out.Result = output
var buff [1024]byte
@@ -39967,7 +40252,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPolicyTablesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMeteringPoliciesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -39981,7 +40266,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayMeteringPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40014,14 +40299,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response *
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayMulticastDomains) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40039,9 +40324,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements)
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response, &metadata)
}
- output := &DescribeTransitGatewayRouteTableAnnouncementsOutput{}
+ output := &DescribeTransitGatewayMulticastDomainsOutput{}
out.Result = output
var buff [1024]byte
@@ -40062,7 +40347,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements)
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTableAnnouncementsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayMulticastDomainsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40076,7 +40361,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements)
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayMulticastDomains(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40109,14 +40394,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayRouteTables struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayPeeringAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40134,9 +40419,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response, &metadata)
}
- output := &DescribeTransitGatewayRouteTablesOutput{}
+ output := &DescribeTransitGatewayPeeringAttachmentsOutput{}
out.Result = output
var buff [1024]byte
@@ -40157,7 +40442,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTablesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPeeringAttachmentsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40171,7 +40456,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayPeeringAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40204,14 +40489,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response *s
}
}
-type awsEc2query_deserializeOpDescribeTransitGateways struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayPolicyTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40229,9 +40514,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response, &metadata)
}
- output := &DescribeTransitGatewaysOutput{}
+ output := &DescribeTransitGatewayPolicyTablesOutput{}
out.Result = output
var buff [1024]byte
@@ -40252,7 +40537,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayPolicyTablesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40266,7 +40551,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayPolicyTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40299,14 +40584,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGateways(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements struct {
}
-func (*awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTableAnnouncements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40324,9 +40609,9 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response, &metadata)
}
- output := &DescribeTransitGatewayVpcAttachmentsOutput{}
+ output := &DescribeTransitGatewayRouteTableAnnouncementsOutput{}
out.Result = output
var buff [1024]byte
@@ -40347,7 +40632,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayVpcAttachmentsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTableAnnouncementsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40361,7 +40646,7 @@ func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTableAnnouncements(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40394,14 +40679,14 @@ func awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response
}
}
-type awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayRouteTables struct {
}
-func (*awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayRouteTables) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40419,9 +40704,9 @@ func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response, &metadata)
}
- output := &DescribeTrunkInterfaceAssociationsOutput{}
+ output := &DescribeTransitGatewayRouteTablesOutput{}
out.Result = output
var buff [1024]byte
@@ -40442,7 +40727,7 @@ func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeTrunkInterfaceAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayRouteTablesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40456,7 +40741,7 @@ func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayRouteTables(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40489,14 +40774,14 @@ func awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response *
}
}
-type awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints struct {
+type awsEc2query_deserializeOpDescribeTransitGateways struct {
}
-func (*awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40514,9 +40799,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGateways(response, &metadata)
}
- output := &DescribeVerifiedAccessEndpointsOutput{}
+ output := &DescribeTransitGatewaysOutput{}
out.Result = output
var buff [1024]byte
@@ -40537,7 +40822,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessEndpointsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewaysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40551,7 +40836,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40584,14 +40869,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response *smi
}
}
-type awsEc2query_deserializeOpDescribeVerifiedAccessGroups struct {
+type awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments struct {
}
-func (*awsEc2query_deserializeOpDescribeVerifiedAccessGroups) ID() string {
+func (*awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTransitGatewayVpcAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40609,9 +40894,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response, &metadata)
}
- output := &DescribeVerifiedAccessGroupsOutput{}
+ output := &DescribeTransitGatewayVpcAttachmentsOutput{}
out.Result = output
var buff [1024]byte
@@ -40632,7 +40917,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessGroupsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTransitGatewayVpcAttachmentsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40646,7 +40931,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTransitGatewayVpcAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40679,14 +40964,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations struct {
+type awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) ID() string {
+func (*awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeTrunkInterfaceAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40704,9 +40989,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigura
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response, &metadata)
}
- output := &DescribeVerifiedAccessInstanceLoggingConfigurationsOutput{}
+ output := &DescribeTrunkInterfaceAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -40727,7 +41012,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigura
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstanceLoggingConfigurationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeTrunkInterfaceAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40741,7 +41026,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigura
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeTrunkInterfaceAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40774,14 +41059,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigur
}
}
-type awsEc2query_deserializeOpDescribeVerifiedAccessInstances struct {
+type awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints struct {
}
-func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstances) ID() string {
+func (*awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVerifiedAccessEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40799,9 +41084,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response, &metadata)
}
- output := &DescribeVerifiedAccessInstancesOutput{}
+ output := &DescribeVerifiedAccessEndpointsOutput{}
out.Result = output
var buff [1024]byte
@@ -40822,7 +41107,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessEndpointsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40836,7 +41121,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVerifiedAccessEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40869,14 +41154,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response *smi
}
}
-type awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders struct {
+type awsEc2query_deserializeOpDescribeVerifiedAccessGroups struct {
}
-func (*awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) ID() string {
+func (*awsEc2query_deserializeOpDescribeVerifiedAccessGroups) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVerifiedAccessGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40894,9 +41179,9 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response, &metadata)
}
- output := &DescribeVerifiedAccessTrustProvidersOutput{}
+ output := &DescribeVerifiedAccessGroupsOutput{}
out.Result = output
var buff [1024]byte
@@ -40917,7 +41202,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessTrustProvidersOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessGroupsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -40931,7 +41216,7 @@ func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVerifiedAccessGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -40964,14 +41249,14 @@ func awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response
}
}
-type awsEc2query_deserializeOpDescribeVolumeAttribute struct {
+type awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations struct {
}
-func (*awsEc2query_deserializeOpDescribeVolumeAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstanceLoggingConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -40989,9 +41274,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response, &metadata)
}
- output := &DescribeVolumeAttributeOutput{}
+ output := &DescribeVerifiedAccessInstanceLoggingConfigurationsOutput{}
out.Result = output
var buff [1024]byte
@@ -41012,7 +41297,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVolumeAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstanceLoggingConfigurationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41026,7 +41311,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstanceLoggingConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41059,14 +41344,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDescribeVolumes struct {
+type awsEc2query_deserializeOpDescribeVerifiedAccessInstances struct {
}
-func (*awsEc2query_deserializeOpDescribeVolumes) ID() string {
+func (*awsEc2query_deserializeOpDescribeVerifiedAccessInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVerifiedAccessInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41084,9 +41369,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response, &metadata)
}
- output := &DescribeVolumesOutput{}
+ output := &DescribeVerifiedAccessInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -41107,7 +41392,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVolumesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41121,7 +41406,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVolumes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVerifiedAccessInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41154,14 +41439,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumes(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpDescribeVolumesModifications struct {
+type awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders struct {
}
-func (*awsEc2query_deserializeOpDescribeVolumesModifications) ID() string {
+func (*awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVerifiedAccessTrustProviders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41179,9 +41464,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumesModifications(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response, &metadata)
}
- output := &DescribeVolumesModificationsOutput{}
+ output := &DescribeVerifiedAccessTrustProvidersOutput{}
out.Result = output
var buff [1024]byte
@@ -41202,7 +41487,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVolumesModificationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVerifiedAccessTrustProvidersOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41216,7 +41501,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVolumesModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVerifiedAccessTrustProviders(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41249,14 +41534,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumesModifications(response *smithy
}
}
-type awsEc2query_deserializeOpDescribeVolumeStatus struct {
+type awsEc2query_deserializeOpDescribeVolumeAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeVolumeStatus) ID() string {
+func (*awsEc2query_deserializeOpDescribeVolumeAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41274,9 +41559,9 @@ func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeStatus(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response, &metadata)
}
- output := &DescribeVolumeStatusOutput{}
+ output := &DescribeVolumeAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -41297,7 +41582,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVolumeStatusOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVolumeAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41311,7 +41596,7 @@ func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVolumeStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41344,14 +41629,14 @@ func awsEc2query_deserializeOpErrorDescribeVolumeStatus(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDescribeVpcAttribute struct {
+type awsEc2query_deserializeOpDescribeVolumes struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcAttribute) ID() string {
+func (*awsEc2query_deserializeOpDescribeVolumes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVolumes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41369,9 +41654,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumes(response, &metadata)
}
- output := &DescribeVpcAttributeOutput{}
+ output := &DescribeVolumesOutput{}
out.Result = output
var buff [1024]byte
@@ -41392,7 +41677,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVolumesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41406,7 +41691,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVolumes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41439,14 +41724,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcAttribute(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions struct {
+type awsEc2query_deserializeOpDescribeVolumesModifications struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) ID() string {
+func (*awsEc2query_deserializeOpDescribeVolumesModifications) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVolumesModifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41464,9 +41749,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) Handle
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumesModifications(response, &metadata)
}
- output := &DescribeVpcBlockPublicAccessExclusionsOutput{}
+ output := &DescribeVolumesModificationsOutput{}
out.Result = output
var buff [1024]byte
@@ -41487,7 +41772,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) Handle
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessExclusionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVolumesModificationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41501,7 +41786,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) Handle
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVolumesModifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41534,14 +41819,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(respon
}
}
-type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions struct {
+type awsEc2query_deserializeOpDescribeVolumeStatus struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) ID() string {
+func (*awsEc2query_deserializeOpDescribeVolumeStatus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVolumeStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41559,9 +41844,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVolumeStatus(response, &metadata)
}
- output := &DescribeVpcBlockPublicAccessOptionsOutput{}
+ output := &DescribeVolumeStatusOutput{}
out.Result = output
var buff [1024]byte
@@ -41582,7 +41867,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVolumeStatusOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41596,7 +41881,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVolumeStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41629,14 +41914,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response
}
}
-type awsEc2query_deserializeOpDescribeVpcClassicLink struct {
+type awsEc2query_deserializeOpDescribeVpcAttribute struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcClassicLink) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41654,9 +41939,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcAttribute(response, &metadata)
}
- output := &DescribeVpcClassicLinkOutput{}
+ output := &DescribeVpcAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -41677,7 +41962,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41691,7 +41976,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41724,14 +42009,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport struct {
+type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessExclusions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41749,9 +42034,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response, &metadata)
}
- output := &DescribeVpcClassicLinkDnsSupportOutput{}
+ output := &DescribeVpcBlockPublicAccessExclusionsOutput{}
out.Result = output
var buff [1024]byte
@@ -41772,7 +42057,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkDnsSupportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessExclusionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41786,7 +42071,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessExclusions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41819,14 +42104,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response *sm
}
}
-type awsEc2query_deserializeOpDescribeVpcEncryptionControls struct {
+type awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEncryptionControls) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcBlockPublicAccessOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41844,9 +42129,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response, &metadata)
}
- output := &DescribeVpcEncryptionControlsOutput{}
+ output := &DescribeVpcBlockPublicAccessOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -41867,7 +42152,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEncryptionControlsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcBlockPublicAccessOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41881,7 +42166,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcBlockPublicAccessOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -41914,14 +42199,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response *smith
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpointAssociations struct {
+type awsEc2query_deserializeOpDescribeVpcClassicLink struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpointAssociations) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcClassicLink) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcClassicLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -41939,9 +42224,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response, &metadata)
}
- output := &DescribeVpcEndpointAssociationsOutput{}
+ output := &DescribeVpcClassicLinkOutput{}
out.Result = output
var buff [1024]byte
@@ -41962,7 +42247,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -41976,7 +42261,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcClassicLink(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42009,14 +42294,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response *smi
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications struct {
+type awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcClassicLinkDnsSupport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42034,9 +42319,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response, &metadata)
}
- output := &DescribeVpcEndpointConnectionNotificationsOutput{}
+ output := &DescribeVpcClassicLinkDnsSupportOutput{}
out.Result = output
var buff [1024]byte
@@ -42057,7 +42342,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionNotificationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcClassicLinkDnsSupportOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42071,7 +42356,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcClassicLinkDnsSupport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42104,14 +42389,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(re
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpointConnections struct {
+type awsEc2query_deserializeOpDescribeVpcEncryptionControls struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpointConnections) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEncryptionControls) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEncryptionControls) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42129,9 +42414,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response, &metadata)
}
- output := &DescribeVpcEndpointConnectionsOutput{}
+ output := &DescribeVpcEncryptionControlsOutput{}
out.Result = output
var buff [1024]byte
@@ -42152,7 +42437,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEncryptionControlsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42166,7 +42451,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEncryptionControls(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42199,14 +42484,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response *smit
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpoints struct {
+type awsEc2query_deserializeOpDescribeVpcEndpointAssociations struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpoints) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpointAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpointAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42224,9 +42509,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response, &metadata)
}
- output := &DescribeVpcEndpointsOutput{}
+ output := &DescribeVpcEndpointAssociationsOutput{}
out.Result = output
var buff [1024]byte
@@ -42247,7 +42532,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointAssociationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42261,7 +42546,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpointAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42294,14 +42579,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations struct {
+type awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnectionNotifications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42319,9 +42604,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) Hand
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response, &metadata)
}
- output := &DescribeVpcEndpointServiceConfigurationsOutput{}
+ output := &DescribeVpcEndpointConnectionNotificationsOutput{}
out.Result = output
var buff [1024]byte
@@ -42342,7 +42627,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) Hand
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServiceConfigurationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionNotificationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42356,7 +42641,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) Hand
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnectionNotifications(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42389,14 +42674,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(resp
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions struct {
+type awsEc2query_deserializeOpDescribeVpcEndpointConnections struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpointConnections) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42414,9 +42699,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response, &metadata)
}
- output := &DescribeVpcEndpointServicePermissionsOutput{}
+ output := &DescribeVpcEndpointConnectionsOutput{}
out.Result = output
var buff [1024]byte
@@ -42437,7 +42722,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicePermissionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointConnectionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42451,7 +42736,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42484,14 +42769,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(respons
}
}
-type awsEc2query_deserializeOpDescribeVpcEndpointServices struct {
+type awsEc2query_deserializeOpDescribeVpcEndpoints struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcEndpointServices) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpoints) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpoints) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42509,9 +42794,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response, &metadata)
}
- output := &DescribeVpcEndpointServicesOutput{}
+ output := &DescribeVpcEndpointsOutput{}
out.Result = output
var buff [1024]byte
@@ -42532,7 +42817,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42546,7 +42831,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpoints(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42579,14 +42864,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response *smithyh
}
}
-type awsEc2query_deserializeOpDescribeVpcPeeringConnections struct {
+type awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcPeeringConnections) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpointServiceConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42604,9 +42889,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response, &metadata)
}
- output := &DescribeVpcPeeringConnectionsOutput{}
+ output := &DescribeVpcEndpointServiceConfigurationsOutput{}
out.Result = output
var buff [1024]byte
@@ -42627,7 +42912,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcPeeringConnectionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServiceConfigurationsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42641,7 +42926,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpointServiceConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42674,14 +42959,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response *smith
}
}
-type awsEc2query_deserializeOpDescribeVpcs struct {
+type awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions struct {
}
-func (*awsEc2query_deserializeOpDescribeVpcs) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42699,9 +42984,9 @@ func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcs(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response, &metadata)
}
- output := &DescribeVpcsOutput{}
+ output := &DescribeVpcEndpointServicePermissionsOutput{}
out.Result = output
var buff [1024]byte
@@ -42722,7 +43007,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpcsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicePermissionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42736,7 +43021,7 @@ func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpcs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42769,14 +43054,14 @@ func awsEc2query_deserializeOpErrorDescribeVpcs(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpDescribeVpnConcentrators struct {
+type awsEc2query_deserializeOpDescribeVpcEndpointServices struct {
}
-func (*awsEc2query_deserializeOpDescribeVpnConcentrators) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcEndpointServices) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcEndpointServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42794,9 +43079,9 @@ func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response, &metadata)
}
- output := &DescribeVpnConcentratorsOutput{}
+ output := &DescribeVpcEndpointServicesOutput{}
out.Result = output
var buff [1024]byte
@@ -42817,7 +43102,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpnConcentratorsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcEndpointServicesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42831,7 +43116,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcEndpointServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42864,14 +43149,14 @@ func awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response *smithyhttp
}
}
-type awsEc2query_deserializeOpDescribeVpnConnections struct {
+type awsEc2query_deserializeOpDescribeVpcPeeringConnections struct {
}
-func (*awsEc2query_deserializeOpDescribeVpnConnections) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcPeeringConnections) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcPeeringConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42889,9 +43174,9 @@ func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConnections(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response, &metadata)
}
- output := &DescribeVpnConnectionsOutput{}
+ output := &DescribeVpcPeeringConnectionsOutput{}
out.Result = output
var buff [1024]byte
@@ -42912,7 +43197,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpnConnectionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcPeeringConnectionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -42926,7 +43211,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcPeeringConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -42959,14 +43244,14 @@ func awsEc2query_deserializeOpErrorDescribeVpnConnections(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDescribeVpnGateways struct {
+type awsEc2query_deserializeOpDescribeVpcs struct {
}
-func (*awsEc2query_deserializeOpDescribeVpnGateways) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpcs) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpcs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -42984,9 +43269,9 @@ func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnGateways(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpcs(response, &metadata)
}
- output := &DescribeVpnGatewaysOutput{}
+ output := &DescribeVpcsOutput{}
out.Result = output
var buff [1024]byte
@@ -43007,7 +43292,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDescribeVpnGatewaysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpcsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43021,7 +43306,7 @@ func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDescribeVpnGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpcs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43054,14 +43339,14 @@ func awsEc2query_deserializeOpErrorDescribeVpnGateways(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDetachClassicLinkVpc struct {
+type awsEc2query_deserializeOpDescribeVpnConcentrators struct {
}
-func (*awsEc2query_deserializeOpDetachClassicLinkVpc) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpnConcentrators) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpnConcentrators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43079,9 +43364,9 @@ func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response, &metadata)
}
- output := &DetachClassicLinkVpcOutput{}
+ output := &DescribeVpnConcentratorsOutput{}
out.Result = output
var buff [1024]byte
@@ -43102,7 +43387,7 @@ func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDetachClassicLinkVpcOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpnConcentratorsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43116,7 +43401,7 @@ func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpnConcentrators(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43149,14 +43434,14 @@ func awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDetachImageWatermark struct {
+type awsEc2query_deserializeOpDescribeVpnConnections struct {
}
-func (*awsEc2query_deserializeOpDetachImageWatermark) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpnConnections) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachImageWatermark) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43174,9 +43459,9 @@ func (m *awsEc2query_deserializeOpDetachImageWatermark) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachImageWatermark(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnConnections(response, &metadata)
}
- output := &DetachImageWatermarkOutput{}
+ output := &DescribeVpnConnectionsOutput{}
out.Result = output
var buff [1024]byte
@@ -43197,7 +43482,7 @@ func (m *awsEc2query_deserializeOpDetachImageWatermark) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDetachImageWatermarkOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDescribeVpnConnectionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43211,7 +43496,7 @@ func (m *awsEc2query_deserializeOpDetachImageWatermark) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachImageWatermark(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43244,14 +43529,14 @@ func awsEc2query_deserializeOpErrorDetachImageWatermark(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpDetachInternetGateway struct {
+type awsEc2query_deserializeOpDescribeVpnGateways struct {
}
-func (*awsEc2query_deserializeOpDetachInternetGateway) ID() string {
+func (*awsEc2query_deserializeOpDescribeVpnGateways) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDescribeVpnGateways) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43269,21 +43554,44 @@ func (m *awsEc2query_deserializeOpDetachInternetGateway) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachInternetGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDescribeVpnGateways(response, &metadata)
}
- output := &DetachInternetGatewayOutput{}
+ output := &DescribeVpnGatewaysOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDescribeVpnGatewaysOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDescribeVpnGateways(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43316,14 +43624,14 @@ func awsEc2query_deserializeOpErrorDetachInternetGateway(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpDetachNetworkInterface struct {
+type awsEc2query_deserializeOpDetachClassicLinkVpc struct {
}
-func (*awsEc2query_deserializeOpDetachNetworkInterface) ID() string {
+func (*awsEc2query_deserializeOpDetachClassicLinkVpc) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDetachClassicLinkVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43341,21 +43649,44 @@ func (m *awsEc2query_deserializeOpDetachNetworkInterface) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachNetworkInterface(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response, &metadata)
}
- output := &DetachNetworkInterfaceOutput{}
+ output := &DetachClassicLinkVpcOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDetachClassicLinkVpcOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDetachClassicLinkVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43388,14 +43719,14 @@ func awsEc2query_deserializeOpErrorDetachNetworkInterface(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider struct {
+type awsEc2query_deserializeOpDetachImageWatermark struct {
}
-func (*awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) ID() string {
+func (*awsEc2query_deserializeOpDetachImageWatermark) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDetachImageWatermark) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43413,9 +43744,9 @@ func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDetachImageWatermark(response, &metadata)
}
- output := &DetachVerifiedAccessTrustProviderOutput{}
+ output := &DetachImageWatermarkOutput{}
out.Result = output
var buff [1024]byte
@@ -43436,7 +43767,7 @@ func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDetachVerifiedAccessTrustProviderOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDetachImageWatermarkOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43450,7 +43781,7 @@ func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDetachImageWatermark(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43483,14 +43814,14 @@ func awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response *s
}
}
-type awsEc2query_deserializeOpDetachVolume struct {
+type awsEc2query_deserializeOpDetachInternetGateway struct {
}
-func (*awsEc2query_deserializeOpDetachVolume) ID() string {
+func (*awsEc2query_deserializeOpDetachInternetGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDetachInternetGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43508,44 +43839,93 @@ func (m *awsEc2query_deserializeOpDetachVolume) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachVolume(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDetachInternetGateway(response, &metadata)
}
- output := &DetachVolumeOutput{}
+ output := &DetachInternetGatewayOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDetachVolumeOutput(&output, decoder)
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDetachInternetGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
}
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDetachNetworkInterface struct {
+}
+
+func (*awsEc2query_deserializeOpDetachNetworkInterface) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDetachNetworkInterface) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
return out, metadata, err
}
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDetachNetworkInterface(response, &metadata)
+ }
+ output := &DetachNetworkInterfaceOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDetachNetworkInterface(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43578,14 +43958,14 @@ func awsEc2query_deserializeOpErrorDetachVolume(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpDetachVpnGateway struct {
+type awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider struct {
}
-func (*awsEc2query_deserializeOpDetachVpnGateway) ID() string {
+func (*awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDetachVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43603,21 +43983,44 @@ func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDetachVpnGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response, &metadata)
}
- output := &DetachVpnGatewayOutput{}
+ output := &DetachVerifiedAccessTrustProviderOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDetachVerifiedAccessTrustProviderOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDetachVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDetachVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43650,14 +44053,14 @@ func awsEc2query_deserializeOpErrorDetachVpnGateway(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpDisableAddressTransfer struct {
+type awsEc2query_deserializeOpDetachVolume struct {
}
-func (*awsEc2query_deserializeOpDisableAddressTransfer) ID() string {
+func (*awsEc2query_deserializeOpDetachVolume) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDetachVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43675,9 +44078,9 @@ func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableAddressTransfer(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDetachVolume(response, &metadata)
}
- output := &DisableAddressTransferOutput{}
+ output := &DetachVolumeOutput{}
out.Result = output
var buff [1024]byte
@@ -43698,7 +44101,7 @@ func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableAddressTransferOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDetachVolumeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43712,7 +44115,7 @@ func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableAddressTransfer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDetachVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43745,14 +44148,14 @@ func awsEc2query_deserializeOpErrorDisableAddressTransfer(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDisableAllowedImagesSettings struct {
+type awsEc2query_deserializeOpDetachVpnGateway struct {
}
-func (*awsEc2query_deserializeOpDisableAllowedImagesSettings) ID() string {
+func (*awsEc2query_deserializeOpDetachVpnGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDetachVpnGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43770,9 +44173,81 @@ func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDetachVpnGateway(response, &metadata)
}
- output := &DisableAllowedImagesSettingsOutput{}
+ output := &DetachVpnGatewayOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDetachVpnGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDisableAddressTransfer struct {
+}
+
+func (*awsEc2query_deserializeOpDisableAddressTransfer) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDisableAddressTransfer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDisableAddressTransfer(response, &metadata)
+ }
+ output := &DisableAddressTransferOutput{}
out.Result = output
var buff [1024]byte
@@ -43793,7 +44268,7 @@ func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableAllowedImagesSettingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableAddressTransferOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43807,7 +44282,7 @@ func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableAddressTransfer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43840,14 +44315,14 @@ func awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response *smithy
}
}
-type awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription struct {
+type awsEc2query_deserializeOpDisableAllowedImagesSettings struct {
}
-func (*awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string {
+func (*awsEc2query_deserializeOpDisableAllowedImagesSettings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43865,9 +44340,9 @@ func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response, &metadata)
}
- output := &DisableAwsNetworkPerformanceMetricSubscriptionOutput{}
+ output := &DisableAllowedImagesSettingsOutput{}
out.Result = output
var buff [1024]byte
@@ -43888,7 +44363,7 @@ func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableAllowedImagesSettingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43902,7 +44377,7 @@ func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -43935,14 +44410,14 @@ func awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscriptio
}
}
-type awsEc2query_deserializeOpDisableCapacityManager struct {
+type awsEc2query_deserializeOpDisableApplicationStatusCheckSuppression struct {
}
-func (*awsEc2query_deserializeOpDisableCapacityManager) ID() string {
+func (*awsEc2query_deserializeOpDisableApplicationStatusCheckSuppression) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableApplicationStatusCheckSuppression) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -43960,9 +44435,9 @@ func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableCapacityManager(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableApplicationStatusCheckSuppression(response, &metadata)
}
- output := &DisableCapacityManagerOutput{}
+ output := &DisableApplicationStatusCheckSuppressionOutput{}
out.Result = output
var buff [1024]byte
@@ -43983,7 +44458,7 @@ func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableCapacityManagerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableApplicationStatusCheckSuppressionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -43997,7 +44472,7 @@ func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableCapacityManager(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableApplicationStatusCheckSuppression(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44030,14 +44505,14 @@ func awsEc2query_deserializeOpErrorDisableCapacityManager(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpDisableEbsEncryptionByDefault struct {
+type awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription struct {
}
-func (*awsEc2query_deserializeOpDisableEbsEncryptionByDefault) ID() string {
+func (*awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44055,9 +44530,9 @@ func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response, &metadata)
}
- output := &DisableEbsEncryptionByDefaultOutput{}
+ output := &DisableAwsNetworkPerformanceMetricSubscriptionOutput{}
out.Result = output
var buff [1024]byte
@@ -44078,7 +44553,7 @@ func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableEbsEncryptionByDefaultOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44092,7 +44567,7 @@ func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableAwsNetworkPerformanceMetricSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44125,14 +44600,14 @@ func awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response *smith
}
}
-type awsEc2query_deserializeOpDisableFastLaunch struct {
+type awsEc2query_deserializeOpDisableCapacityManager struct {
}
-func (*awsEc2query_deserializeOpDisableFastLaunch) ID() string {
+func (*awsEc2query_deserializeOpDisableCapacityManager) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableCapacityManager) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44150,9 +44625,9 @@ func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableFastLaunch(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableCapacityManager(response, &metadata)
}
- output := &DisableFastLaunchOutput{}
+ output := &DisableCapacityManagerOutput{}
out.Result = output
var buff [1024]byte
@@ -44173,7 +44648,7 @@ func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableFastLaunchOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableCapacityManagerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44187,7 +44662,7 @@ func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableFastLaunch(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableCapacityManager(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44220,14 +44695,14 @@ func awsEc2query_deserializeOpErrorDisableFastLaunch(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpDisableFastSnapshotRestores struct {
+type awsEc2query_deserializeOpDisableEbsEncryptionByDefault struct {
}
-func (*awsEc2query_deserializeOpDisableFastSnapshotRestores) ID() string {
+func (*awsEc2query_deserializeOpDisableEbsEncryptionByDefault) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableEbsEncryptionByDefault) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44245,9 +44720,9 @@ func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response, &metadata)
}
- output := &DisableFastSnapshotRestoresOutput{}
+ output := &DisableEbsEncryptionByDefaultOutput{}
out.Result = output
var buff [1024]byte
@@ -44268,7 +44743,7 @@ func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableFastSnapshotRestoresOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableEbsEncryptionByDefaultOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44282,7 +44757,7 @@ func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableEbsEncryptionByDefault(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44315,14 +44790,14 @@ func awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response *smithyh
}
}
-type awsEc2query_deserializeOpDisableImage struct {
+type awsEc2query_deserializeOpDisableFastLaunch struct {
}
-func (*awsEc2query_deserializeOpDisableImage) ID() string {
+func (*awsEc2query_deserializeOpDisableFastLaunch) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableFastLaunch) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44340,9 +44815,9 @@ func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableFastLaunch(response, &metadata)
}
- output := &DisableImageOutput{}
+ output := &DisableFastLaunchOutput{}
out.Result = output
var buff [1024]byte
@@ -44363,7 +44838,7 @@ func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableFastLaunchOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44377,7 +44852,7 @@ func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableFastLaunch(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44410,14 +44885,14 @@ func awsEc2query_deserializeOpErrorDisableImage(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpDisableImageBlockPublicAccess struct {
+type awsEc2query_deserializeOpDisableFastSnapshotRestores struct {
}
-func (*awsEc2query_deserializeOpDisableImageBlockPublicAccess) ID() string {
+func (*awsEc2query_deserializeOpDisableFastSnapshotRestores) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableFastSnapshotRestores) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44435,9 +44910,9 @@ func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response, &metadata)
}
- output := &DisableImageBlockPublicAccessOutput{}
+ output := &DisableFastSnapshotRestoresOutput{}
out.Result = output
var buff [1024]byte
@@ -44458,7 +44933,7 @@ func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableImageBlockPublicAccessOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableFastSnapshotRestoresOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44472,7 +44947,7 @@ func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableFastSnapshotRestores(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44505,14 +44980,14 @@ func awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response *smith
}
}
-type awsEc2query_deserializeOpDisableImageDeprecation struct {
+type awsEc2query_deserializeOpDisableImage struct {
}
-func (*awsEc2query_deserializeOpDisableImageDeprecation) ID() string {
+func (*awsEc2query_deserializeOpDisableImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44530,9 +45005,9 @@ func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeprecation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableImage(response, &metadata)
}
- output := &DisableImageDeprecationOutput{}
+ output := &DisableImageOutput{}
out.Result = output
var buff [1024]byte
@@ -44553,7 +45028,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableImageDeprecationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44567,7 +45042,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableImageDeprecation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -44600,14 +45075,14 @@ func awsEc2query_deserializeOpErrorDisableImageDeprecation(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpDisableImageDeregistrationProtection struct {
+type awsEc2query_deserializeOpDisableImageBlockPublicAccess struct {
}
-func (*awsEc2query_deserializeOpDisableImageDeregistrationProtection) ID() string {
+func (*awsEc2query_deserializeOpDisableImageBlockPublicAccess) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisableImageBlockPublicAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -44625,9 +45100,9 @@ func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response, &metadata)
}
- output := &DisableImageDeregistrationProtectionOutput{}
+ output := &DisableImageBlockPublicAccessOutput{}
out.Result = output
var buff [1024]byte
@@ -44648,7 +45123,7 @@ func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisableImageDeregistrationProtectionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisableImageBlockPublicAccessOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -44662,7 +45137,197 @@ func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisableImageBlockPublicAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDisableImageDeprecation struct {
+}
+
+func (*awsEc2query_deserializeOpDisableImageDeprecation) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDisableImageDeprecation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeprecation(response, &metadata)
+ }
+ output := &DisableImageDeprecationOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDisableImageDeprecationOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDisableImageDeprecation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDisableImageDeregistrationProtection struct {
+}
+
+func (*awsEc2query_deserializeOpDisableImageDeregistrationProtection) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDisableImageDeregistrationProtection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response, &metadata)
+ }
+ output := &DisableImageDeregistrationProtectionOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDisableImageDeregistrationProtectionOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDisableImageDeregistrationProtection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -45694,14 +46359,14 @@ func awsEc2query_deserializeOpErrorDisassociateAddress(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner struct {
+type awsEc2query_deserializeOpDisassociateApplicationStatusCheck struct {
}
-func (*awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) ID() string {
+func (*awsEc2query_deserializeOpDisassociateApplicationStatusCheck) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisassociateApplicationStatusCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -45719,9 +46384,9 @@ func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateApplicationStatusCheck(response, &metadata)
}
- output := &DisassociateCapacityReservationBillingOwnerOutput{}
+ output := &DisassociateApplicationStatusCheckOutput{}
out.Result = output
var buff [1024]byte
@@ -45742,7 +46407,7 @@ func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisassociateCapacityReservationBillingOwnerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisassociateApplicationStatusCheckOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -45756,7 +46421,7 @@ func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisassociateApplicationStatusCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -45789,14 +46454,14 @@ func awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(r
}
}
-type awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork struct {
+type awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner struct {
}
-func (*awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) ID() string {
+func (*awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisassociateCapacityReservationBillingOwner) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -45814,9 +46479,9 @@ func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response, &metadata)
}
- output := &DisassociateClientVpnTargetNetworkOutput{}
+ output := &DisassociateCapacityReservationBillingOwnerOutput{}
out.Result = output
var buff [1024]byte
@@ -45837,7 +46502,7 @@ func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisassociateClientVpnTargetNetworkOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisassociateCapacityReservationBillingOwnerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -45851,7 +46516,7 @@ func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisassociateCapacityReservationBillingOwner(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -45884,14 +46549,14 @@ func awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response *
}
}
-type awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole struct {
+type awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork struct {
}
-func (*awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) ID() string {
+func (*awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisassociateClientVpnTargetNetwork) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -45909,9 +46574,9 @@ func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response, &metadata)
}
- output := &DisassociateEnclaveCertificateIamRoleOutput{}
+ output := &DisassociateClientVpnTargetNetworkOutput{}
out.Result = output
var buff [1024]byte
@@ -45932,7 +46597,7 @@ func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisassociateEnclaveCertificateIamRoleOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisassociateClientVpnTargetNetworkOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -45946,7 +46611,7 @@ func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisassociateClientVpnTargetNetwork(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -45979,14 +46644,14 @@ func awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(respons
}
}
-type awsEc2query_deserializeOpDisassociateIamInstanceProfile struct {
+type awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole struct {
}
-func (*awsEc2query_deserializeOpDisassociateIamInstanceProfile) ID() string {
+func (*awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisassociateEnclaveCertificateIamRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -46004,9 +46669,9 @@ func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response, &metadata)
}
- output := &DisassociateIamInstanceProfileOutput{}
+ output := &DisassociateEnclaveCertificateIamRoleOutput{}
out.Result = output
var buff [1024]byte
@@ -46027,7 +46692,7 @@ func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisassociateIamInstanceProfileOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisassociateEnclaveCertificateIamRoleOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -46041,7 +46706,7 @@ func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisassociateEnclaveCertificateIamRole(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -46074,14 +46739,14 @@ func awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response *smit
}
}
-type awsEc2query_deserializeOpDisassociateInstanceEventWindow struct {
+type awsEc2query_deserializeOpDisassociateIamInstanceProfile struct {
}
-func (*awsEc2query_deserializeOpDisassociateInstanceEventWindow) ID() string {
+func (*awsEc2query_deserializeOpDisassociateIamInstanceProfile) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisassociateIamInstanceProfile) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -46099,9 +46764,9 @@ func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response, &metadata)
}
- output := &DisassociateInstanceEventWindowOutput{}
+ output := &DisassociateIamInstanceProfileOutput{}
out.Result = output
var buff [1024]byte
@@ -46122,7 +46787,7 @@ func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisassociateInstanceEventWindowOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisassociateIamInstanceProfileOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -46136,7 +46801,7 @@ func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisassociateIamInstanceProfile(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -46169,14 +46834,14 @@ func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smi
}
}
-type awsEc2query_deserializeOpDisassociateIpamByoasn struct {
+type awsEc2query_deserializeOpDisassociateInstanceEventWindow struct {
}
-func (*awsEc2query_deserializeOpDisassociateIpamByoasn) ID() string {
+func (*awsEc2query_deserializeOpDisassociateInstanceEventWindow) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpDisassociateInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -46194,9 +46859,9 @@ func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response, &metadata)
}
- output := &DisassociateIpamByoasnOutput{}
+ output := &DisassociateInstanceEventWindowOutput{}
out.Result = output
var buff [1024]byte
@@ -46217,7 +46882,7 @@ func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentDisassociateIpamByoasnOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentDisassociateInstanceEventWindowOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -46231,7 +46896,102 @@ func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorDisassociateInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpDisassociateIpamByoasn struct {
+}
+
+func (*awsEc2query_deserializeOpDisassociateIpamByoasn) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpDisassociateIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response, &metadata)
+ }
+ output := &DisassociateIpamByoasnOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentDisassociateIpamByoasnOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorDisassociateIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -47476,6 +48236,101 @@ func awsEc2query_deserializeOpErrorEnableAllowedImagesSettings(response *smithyh
}
}
+type awsEc2query_deserializeOpEnableApplicationStatusCheckSuppression struct {
+}
+
+func (*awsEc2query_deserializeOpEnableApplicationStatusCheckSuppression) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpEnableApplicationStatusCheckSuppression) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorEnableApplicationStatusCheckSuppression(response, &metadata)
+ }
+ output := &EnableApplicationStatusCheckSuppressionOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentEnableApplicationStatusCheckSuppressionOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorEnableApplicationStatusCheckSuppression(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
type awsEc2query_deserializeOpEnableAwsNetworkPerformanceMetricSubscription struct {
}
@@ -57690,14 +58545,14 @@ func awsEc2query_deserializeOpErrorModifyAddressAttribute(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpModifyAvailabilityZoneGroup struct {
+type awsEc2query_deserializeOpModifyApplicationStatusCheck struct {
}
-func (*awsEc2query_deserializeOpModifyAvailabilityZoneGroup) ID() string {
+func (*awsEc2query_deserializeOpModifyApplicationStatusCheck) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyApplicationStatusCheck) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -57715,9 +58570,9 @@ func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyApplicationStatusCheck(response, &metadata)
}
- output := &ModifyAvailabilityZoneGroupOutput{}
+ output := &ModifyApplicationStatusCheckOutput{}
out.Result = output
var buff [1024]byte
@@ -57738,7 +58593,7 @@ func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyAvailabilityZoneGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyApplicationStatusCheckOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -57752,7 +58607,7 @@ func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyApplicationStatusCheck(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -57785,14 +58640,14 @@ func awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response *smithyh
}
}
-type awsEc2query_deserializeOpModifyCapacityReservation struct {
+type awsEc2query_deserializeOpModifyAvailabilityZoneGroup struct {
}
-func (*awsEc2query_deserializeOpModifyCapacityReservation) ID() string {
+func (*awsEc2query_deserializeOpModifyAvailabilityZoneGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyAvailabilityZoneGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -57810,9 +58665,9 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response, &metadata)
}
- output := &ModifyCapacityReservationOutput{}
+ output := &ModifyAvailabilityZoneGroupOutput{}
out.Result = output
var buff [1024]byte
@@ -57833,7 +58688,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyCapacityReservationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyAvailabilityZoneGroupOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -57847,7 +58702,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyAvailabilityZoneGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -57880,14 +58735,14 @@ func awsEc2query_deserializeOpErrorModifyCapacityReservation(response *smithyhtt
}
}
-type awsEc2query_deserializeOpModifyCapacityReservationFleet struct {
+type awsEc2query_deserializeOpModifyCapacityReservation struct {
}
-func (*awsEc2query_deserializeOpModifyCapacityReservationFleet) ID() string {
+func (*awsEc2query_deserializeOpModifyCapacityReservation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyCapacityReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -57905,9 +58760,9 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservation(response, &metadata)
}
- output := &ModifyCapacityReservationFleetOutput{}
+ output := &ModifyCapacityReservationOutput{}
out.Result = output
var buff [1024]byte
@@ -57928,7 +58783,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyCapacityReservationFleetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyCapacityReservationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -57942,7 +58797,7 @@ func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyCapacityReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -57975,14 +58830,14 @@ func awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response *smit
}
}
-type awsEc2query_deserializeOpModifyClientVpnEndpoint struct {
+type awsEc2query_deserializeOpModifyCapacityReservationFleet struct {
}
-func (*awsEc2query_deserializeOpModifyClientVpnEndpoint) ID() string {
+func (*awsEc2query_deserializeOpModifyCapacityReservationFleet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyCapacityReservationFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58000,9 +58855,9 @@ func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response, &metadata)
}
- output := &ModifyClientVpnEndpointOutput{}
+ output := &ModifyCapacityReservationFleetOutput{}
out.Result = output
var buff [1024]byte
@@ -58023,7 +58878,7 @@ func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyClientVpnEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyCapacityReservationFleetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -58037,7 +58892,7 @@ func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyCapacityReservationFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58070,14 +58925,14 @@ func awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifyDefaultCreditSpecification struct {
+type awsEc2query_deserializeOpModifyClientVpnEndpoint struct {
}
-func (*awsEc2query_deserializeOpModifyDefaultCreditSpecification) ID() string {
+func (*awsEc2query_deserializeOpModifyClientVpnEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyClientVpnEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58095,9 +58950,9 @@ func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response, &metadata)
}
- output := &ModifyDefaultCreditSpecificationOutput{}
+ output := &ModifyClientVpnEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -58118,7 +58973,7 @@ func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyDefaultCreditSpecificationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyClientVpnEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -58132,7 +58987,7 @@ func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyClientVpnEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58165,14 +59020,14 @@ func awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response *sm
}
}
-type awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId struct {
+type awsEc2query_deserializeOpModifyDefaultCreditSpecification struct {
}
-func (*awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) ID() string {
+func (*awsEc2query_deserializeOpModifyDefaultCreditSpecification) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyDefaultCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58190,9 +59045,9 @@ func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response, &metadata)
}
- output := &ModifyEbsDefaultKmsKeyIdOutput{}
+ output := &ModifyDefaultCreditSpecificationOutput{}
out.Result = output
var buff [1024]byte
@@ -58213,7 +59068,7 @@ func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyEbsDefaultKmsKeyIdOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyDefaultCreditSpecificationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -58227,7 +59082,7 @@ func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyDefaultCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58260,14 +59115,14 @@ func awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response *smithyhttp
}
}
-type awsEc2query_deserializeOpModifyFleet struct {
+type awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId struct {
}
-func (*awsEc2query_deserializeOpModifyFleet) ID() string {
+func (*awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58285,9 +59140,9 @@ func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyFleet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response, &metadata)
}
- output := &ModifyFleetOutput{}
+ output := &ModifyEbsDefaultKmsKeyIdOutput{}
out.Result = output
var buff [1024]byte
@@ -58308,7 +59163,7 @@ func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyFleetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyEbsDefaultKmsKeyIdOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -58322,7 +59177,7 @@ func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58355,14 +59210,14 @@ func awsEc2query_deserializeOpErrorModifyFleet(response *smithyhttp.Response, me
}
}
-type awsEc2query_deserializeOpModifyFpgaImageAttribute struct {
+type awsEc2query_deserializeOpModifyFleet struct {
}
-func (*awsEc2query_deserializeOpModifyFpgaImageAttribute) ID() string {
+func (*awsEc2query_deserializeOpModifyFleet) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58380,9 +59235,9 @@ func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyFleet(response, &metadata)
}
- output := &ModifyFpgaImageAttributeOutput{}
+ output := &ModifyFleetOutput{}
out.Result = output
var buff [1024]byte
@@ -58403,7 +59258,7 @@ func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyFpgaImageAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyFleetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -58417,7 +59272,7 @@ func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58450,14 +59305,14 @@ func awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response *smithyhttp
}
}
-type awsEc2query_deserializeOpModifyHosts struct {
+type awsEc2query_deserializeOpModifyFpgaImageAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyHosts) ID() string {
+func (*awsEc2query_deserializeOpModifyFpgaImageAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58475,9 +59330,9 @@ func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyHosts(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response, &metadata)
}
- output := &ModifyHostsOutput{}
+ output := &ModifyFpgaImageAttributeOutput{}
out.Result = output
var buff [1024]byte
@@ -58498,7 +59353,7 @@ func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyHostsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyFpgaImageAttributeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -58512,7 +59367,7 @@ func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58545,14 +59400,14 @@ func awsEc2query_deserializeOpErrorModifyHosts(response *smithyhttp.Response, me
}
}
-type awsEc2query_deserializeOpModifyIdentityIdFormat struct {
+type awsEc2query_deserializeOpModifyHosts struct {
}
-func (*awsEc2query_deserializeOpModifyIdentityIdFormat) ID() string {
+func (*awsEc2query_deserializeOpModifyHosts) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIdentityIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58570,93 +59425,44 @@ func (m *awsEc2query_deserializeOpModifyIdentityIdFormat) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyHosts(response, &metadata)
}
- output := &ModifyIdentityIdFormatOutput{}
+ output := &ModifyHostsOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
- }
- }
-
- return out, metadata, err
-}
-
-func awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
- var errorBuffer bytes.Buffer
- if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
- return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
}
- errorBody := bytes.NewReader(errorBuffer.Bytes())
-
- errorCode := "UnknownError"
- errorMessage := errorCode
-
- errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
if err != nil {
- return err
- }
- awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
- if len(errorComponents.Code) != 0 {
- errorCode = errorComponents.Code
- }
- if len(errorComponents.Message) != 0 {
- errorMessage = errorComponents.Message
- }
- errorBody.Seek(0, io.SeekStart)
- switch {
- default:
- genericError := &smithy.GenericAPIError{
- Code: errorCode,
- Message: errorMessage,
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
- return genericError
-
}
-}
-
-type awsEc2query_deserializeOpModifyIdFormat struct {
-}
-
-func (*awsEc2query_deserializeOpModifyIdFormat) ID() string {
- return "OperationDeserializer"
-}
-func (m *awsEc2query_deserializeOpModifyIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
- out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
-) {
- out, metadata, err = next.HandleDeserialize(ctx, in)
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentModifyHostsOutput(&output, decoder)
if err != nil {
- return out, metadata, err
- }
-
- _, span := tracing.StartSpan(ctx, "OperationDeserializer")
- endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
- defer endTimer()
- defer span.End()
- response, ok := out.RawResponse.(*smithyhttp.Response)
- if !ok {
- return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
- }
-
- if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIdFormat(response, &metadata)
- }
- output := &ModifyIdFormatOutput{}
- out.Result = output
-
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58689,14 +59495,14 @@ func awsEc2query_deserializeOpErrorModifyIdFormat(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpModifyImageAttribute struct {
+type awsEc2query_deserializeOpModifyIdentityIdFormat struct {
}
-func (*awsEc2query_deserializeOpModifyImageAttribute) ID() string {
+func (*awsEc2query_deserializeOpModifyIdentityIdFormat) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIdentityIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58714,9 +59520,9 @@ func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyImageAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response, &metadata)
}
- output := &ModifyImageAttributeOutput{}
+ output := &ModifyIdentityIdFormatOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -58728,7 +59534,7 @@ func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIdentityIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58761,14 +59567,14 @@ func awsEc2query_deserializeOpErrorModifyImageAttribute(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpModifyInstanceAttribute struct {
+type awsEc2query_deserializeOpModifyIdFormat struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceAttribute) ID() string {
+func (*awsEc2query_deserializeOpModifyIdFormat) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIdFormat) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58786,9 +59592,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIdFormat(response, &metadata)
}
- output := &ModifyInstanceAttributeOutput{}
+ output := &ModifyIdFormatOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -58800,7 +59606,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceAttribute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIdFormat(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58833,14 +59639,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceAttribute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes struct {
+type awsEc2query_deserializeOpModifyImageAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) ID() string {
+func (*awsEc2query_deserializeOpModifyImageAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58858,44 +59664,21 @@ func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyImageAttribute(response, &metadata)
}
- output := &ModifyInstanceCapacityReservationAttributesOutput{}
+ output := &ModifyImageAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceCapacityReservationAttributesOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -58928,14 +59711,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(r
}
}
-type awsEc2query_deserializeOpModifyInstanceConnectEndpoint struct {
+type awsEc2query_deserializeOpModifyInstanceAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceConnectEndpoint) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -58953,44 +59736,21 @@ func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceAttribute(response, &metadata)
}
- output := &ModifyInstanceConnectEndpointOutput{}
+ output := &ModifyInstanceAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceConnectEndpointOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59023,14 +59783,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response *smith
}
}
-type awsEc2query_deserializeOpModifyInstanceCpuOptions struct {
+type awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceCpuOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceCapacityReservationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59048,9 +59808,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response, &metadata)
}
- output := &ModifyInstanceCpuOptionsOutput{}
+ output := &ModifyInstanceCapacityReservationAttributesOutput{}
out.Result = output
var buff [1024]byte
@@ -59071,7 +59831,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceCpuOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceCapacityReservationAttributesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59085,7 +59845,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceCapacityReservationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59118,14 +59878,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response *smithyhttp
}
}
-type awsEc2query_deserializeOpModifyInstanceCreditSpecification struct {
+type awsEc2query_deserializeOpModifyInstanceConnectEndpoint struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceCreditSpecification) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceConnectEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceConnectEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59143,9 +59903,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response, &metadata)
}
- output := &ModifyInstanceCreditSpecificationOutput{}
+ output := &ModifyInstanceConnectEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -59166,7 +59926,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceCreditSpecificationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceConnectEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59180,7 +59940,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceConnectEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59213,14 +59973,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response *s
}
}
-type awsEc2query_deserializeOpModifyInstanceEventStartTime struct {
+type awsEc2query_deserializeOpModifyInstanceCpuOptions struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceEventStartTime) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceCpuOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceCpuOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59238,9 +59998,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response, &metadata)
}
- output := &ModifyInstanceEventStartTimeOutput{}
+ output := &ModifyInstanceCpuOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -59261,7 +60021,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceEventStartTimeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceCpuOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59275,7 +60035,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceCpuOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59308,14 +60068,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response *smithy
}
}
-type awsEc2query_deserializeOpModifyInstanceEventWindow struct {
+type awsEc2query_deserializeOpModifyInstanceCreditSpecification struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceEventWindow) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceCreditSpecification) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceCreditSpecification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59333,9 +60093,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response, &metadata)
}
- output := &ModifyInstanceEventWindowOutput{}
+ output := &ModifyInstanceCreditSpecificationOutput{}
out.Result = output
var buff [1024]byte
@@ -59356,7 +60116,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceEventWindowOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceCreditSpecificationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59370,7 +60130,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceCreditSpecification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59403,14 +60163,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response *smithyhtt
}
}
-type awsEc2query_deserializeOpModifyInstanceMaintenanceOptions struct {
+type awsEc2query_deserializeOpModifyInstanceEventStartTime struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceEventStartTime) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceEventStartTime) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59428,9 +60188,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response, &metadata)
}
- output := &ModifyInstanceMaintenanceOptionsOutput{}
+ output := &ModifyInstanceEventStartTimeOutput{}
out.Result = output
var buff [1024]byte
@@ -59451,7 +60211,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceMaintenanceOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceEventStartTimeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59465,7 +60225,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceEventStartTime(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59498,14 +60258,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response *sm
}
}
-type awsEc2query_deserializeOpModifyInstanceMetadataDefaults struct {
+type awsEc2query_deserializeOpModifyInstanceEventWindow struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceMetadataDefaults) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceEventWindow) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceEventWindow) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59523,9 +60283,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response, &metadata)
}
- output := &ModifyInstanceMetadataDefaultsOutput{}
+ output := &ModifyInstanceEventWindowOutput{}
out.Result = output
var buff [1024]byte
@@ -59546,7 +60306,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataDefaultsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceEventWindowOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59560,7 +60320,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceEventWindow(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59593,14 +60353,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response *smit
}
}
-type awsEc2query_deserializeOpModifyInstanceMetadataOptions struct {
+type awsEc2query_deserializeOpModifyInstanceMaintenanceOptions struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceMetadataOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceMaintenanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59618,9 +60378,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response, &metadata)
}
- output := &ModifyInstanceMetadataOptionsOutput{}
+ output := &ModifyInstanceMaintenanceOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -59641,7 +60401,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceMaintenanceOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59655,7 +60415,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceMaintenanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59688,14 +60448,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smith
}
}
-type awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions struct {
+type awsEc2query_deserializeOpModifyInstanceMetadataDefaults struct {
}
-func (*awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceMetadataDefaults) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceMetadataDefaults) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59713,9 +60473,9 @@ func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response, &metadata)
}
- output := &ModifyInstanceNetworkPerformanceOptionsOutput{}
+ output := &ModifyInstanceMetadataDefaultsOutput{}
out.Result = output
var buff [1024]byte
@@ -59736,7 +60496,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstanceNetworkPerformanceOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataDefaultsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59750,7 +60510,7 @@ func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceMetadataDefaults(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59783,14 +60543,14 @@ func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(respo
}
}
-type awsEc2query_deserializeOpModifyInstancePlacement struct {
+type awsEc2query_deserializeOpModifyInstanceMetadataOptions struct {
}
-func (*awsEc2query_deserializeOpModifyInstancePlacement) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceMetadataOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceMetadataOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59808,9 +60568,9 @@ func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyInstancePlacement(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response, &metadata)
}
- output := &ModifyInstancePlacementOutput{}
+ output := &ModifyInstanceMetadataOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -59831,7 +60591,7 @@ func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyInstancePlacementOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceMetadataOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59845,7 +60605,7 @@ func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyInstancePlacement(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceMetadataOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59878,14 +60638,14 @@ func awsEc2query_deserializeOpErrorModifyInstancePlacement(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifyIpam struct {
+type awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions struct {
}
-func (*awsEc2query_deserializeOpModifyIpam) ID() string {
+func (*awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstanceNetworkPerformanceOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59903,9 +60663,9 @@ func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpam(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response, &metadata)
}
- output := &ModifyIpamOutput{}
+ output := &ModifyInstanceNetworkPerformanceOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -59926,7 +60686,7 @@ func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstanceNetworkPerformanceOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -59940,7 +60700,7 @@ func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstanceNetworkPerformanceOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -59973,14 +60733,14 @@ func awsEc2query_deserializeOpErrorModifyIpam(response *smithyhttp.Response, met
}
}
-type awsEc2query_deserializeOpModifyIpamPolicyAllocationRules struct {
+type awsEc2query_deserializeOpModifyInstancePlacement struct {
}
-func (*awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) ID() string {
+func (*awsEc2query_deserializeOpModifyInstancePlacement) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyInstancePlacement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -59998,9 +60758,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyInstancePlacement(response, &metadata)
}
- output := &ModifyIpamPolicyAllocationRulesOutput{}
+ output := &ModifyInstancePlacementOutput{}
out.Result = output
var buff [1024]byte
@@ -60021,7 +60781,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamPolicyAllocationRulesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyInstancePlacementOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60035,7 +60795,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyInstancePlacement(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60068,14 +60828,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response *smi
}
}
-type awsEc2query_deserializeOpModifyIpamPool struct {
+type awsEc2query_deserializeOpModifyIpam struct {
}
-func (*awsEc2query_deserializeOpModifyIpamPool) ID() string {
+func (*awsEc2query_deserializeOpModifyIpam) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60093,9 +60853,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPool(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpam(response, &metadata)
}
- output := &ModifyIpamPoolOutput{}
+ output := &ModifyIpamOutput{}
out.Result = output
var buff [1024]byte
@@ -60116,7 +60876,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamPoolOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60130,7 +60890,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60163,14 +60923,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPool(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpModifyIpamPoolAllocation struct {
+type awsEc2query_deserializeOpModifyIpamPolicyAllocationRules struct {
}
-func (*awsEc2query_deserializeOpModifyIpamPoolAllocation) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamPoolAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamPolicyAllocationRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60188,9 +60948,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPoolAllocation) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPoolAllocation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response, &metadata)
}
- output := &ModifyIpamPoolAllocationOutput{}
+ output := &ModifyIpamPolicyAllocationRulesOutput{}
out.Result = output
var buff [1024]byte
@@ -60211,7 +60971,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPoolAllocation) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamPoolAllocationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamPolicyAllocationRulesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60225,7 +60985,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPoolAllocation) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamPoolAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamPolicyAllocationRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60258,14 +61018,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPoolAllocation(response *smithyhttp
}
}
-type awsEc2query_deserializeOpModifyIpamPrefixListResolver struct {
+type awsEc2query_deserializeOpModifyIpamPool struct {
}
-func (*awsEc2query_deserializeOpModifyIpamPrefixListResolver) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamPool) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamPool) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60283,9 +61043,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPool(response, &metadata)
}
- output := &ModifyIpamPrefixListResolverOutput{}
+ output := &ModifyIpamPoolOutput{}
out.Result = output
var buff [1024]byte
@@ -60306,7 +61066,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamPoolOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60320,7 +61080,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamPool(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60353,14 +61113,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response *smithy
}
}
-type awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget struct {
+type awsEc2query_deserializeOpModifyIpamPoolAllocation struct {
}
-func (*awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamPoolAllocation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamPoolAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60378,9 +61138,9 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPoolAllocation(response, &metadata)
}
- output := &ModifyIpamPrefixListResolverTargetOutput{}
+ output := &ModifyIpamPoolAllocationOutput{}
out.Result = output
var buff [1024]byte
@@ -60401,7 +61161,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverTargetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamPoolAllocationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60415,7 +61175,7 @@ func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamPoolAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60448,14 +61208,14 @@ func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response *
}
}
-type awsEc2query_deserializeOpModifyIpamResourceCidr struct {
+type awsEc2query_deserializeOpModifyIpamPrefixListResolver struct {
}
-func (*awsEc2query_deserializeOpModifyIpamResourceCidr) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamPrefixListResolver) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolver) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60473,9 +61233,9 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response, &metadata)
}
- output := &ModifyIpamResourceCidrOutput{}
+ output := &ModifyIpamPrefixListResolverOutput{}
out.Result = output
var buff [1024]byte
@@ -60496,7 +61256,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamResourceCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60510,7 +61270,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolver(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60543,14 +61303,14 @@ func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpModifyIpamResourceDiscovery struct {
+type awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget struct {
}
-func (*awsEc2query_deserializeOpModifyIpamResourceDiscovery) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamPrefixListResolverTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60568,9 +61328,9 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response, &metadata)
}
- output := &ModifyIpamResourceDiscoveryOutput{}
+ output := &ModifyIpamPrefixListResolverTargetOutput{}
out.Result = output
var buff [1024]byte
@@ -60591,7 +61351,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamResourceDiscoveryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamPrefixListResolverTargetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60605,7 +61365,7 @@ func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamPrefixListResolverTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60638,14 +61398,14 @@ func awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response *smithyh
}
}
-type awsEc2query_deserializeOpModifyIpamScope struct {
+type awsEc2query_deserializeOpModifyIpamResourceCidr struct {
}
-func (*awsEc2query_deserializeOpModifyIpamScope) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamResourceCidr) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamResourceCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60663,9 +61423,9 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyIpamScope(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response, &metadata)
}
- output := &ModifyIpamScopeOutput{}
+ output := &ModifyIpamResourceCidrOutput{}
out.Result = output
var buff [1024]byte
@@ -60686,7 +61446,7 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamResourceCidrOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60700,7 +61460,7 @@ func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamResourceCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60733,14 +61493,14 @@ func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpModifyLaunchTemplate struct {
+type awsEc2query_deserializeOpModifyIpamResourceDiscovery struct {
}
-func (*awsEc2query_deserializeOpModifyLaunchTemplate) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamResourceDiscovery) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamResourceDiscovery) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60758,9 +61518,9 @@ func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyLaunchTemplate(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response, &metadata)
}
- output := &ModifyLaunchTemplateOutput{}
+ output := &ModifyIpamResourceDiscoveryOutput{}
out.Result = output
var buff [1024]byte
@@ -60781,7 +61541,7 @@ func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyLaunchTemplateOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamResourceDiscoveryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60795,7 +61555,7 @@ func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamResourceDiscovery(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60828,14 +61588,14 @@ func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpModifyLocalGatewayRoute struct {
+type awsEc2query_deserializeOpModifyIpamScope struct {
}
-func (*awsEc2query_deserializeOpModifyLocalGatewayRoute) ID() string {
+func (*awsEc2query_deserializeOpModifyIpamScope) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyIpamScope) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60853,9 +61613,9 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyIpamScope(response, &metadata)
}
- output := &ModifyLocalGatewayRouteOutput{}
+ output := &ModifyIpamScopeOutput{}
out.Result = output
var buff [1024]byte
@@ -60876,7 +61636,7 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyLocalGatewayRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyIpamScopeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60890,7 +61650,7 @@ func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyIpamScope(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -60923,14 +61683,14 @@ func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifyManagedPrefixList struct {
+type awsEc2query_deserializeOpModifyLaunchTemplate struct {
}
-func (*awsEc2query_deserializeOpModifyManagedPrefixList) ID() string {
+func (*awsEc2query_deserializeOpModifyLaunchTemplate) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyLaunchTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -60948,9 +61708,9 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyManagedPrefixList(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyLaunchTemplate(response, &metadata)
}
- output := &ModifyManagedPrefixListOutput{}
+ output := &ModifyLaunchTemplateOutput{}
out.Result = output
var buff [1024]byte
@@ -60971,7 +61731,7 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyManagedPrefixListOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyLaunchTemplateOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -60985,7 +61745,7 @@ func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyLaunchTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61018,14 +61778,14 @@ func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifyManagedResourceVisibility struct {
+type awsEc2query_deserializeOpModifyLocalGatewayRoute struct {
}
-func (*awsEc2query_deserializeOpModifyManagedResourceVisibility) ID() string {
+func (*awsEc2query_deserializeOpModifyLocalGatewayRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyManagedResourceVisibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyLocalGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61043,9 +61803,9 @@ func (m *awsEc2query_deserializeOpModifyManagedResourceVisibility) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyManagedResourceVisibility(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response, &metadata)
}
- output := &ModifyManagedResourceVisibilityOutput{}
+ output := &ModifyLocalGatewayRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -61066,7 +61826,7 @@ func (m *awsEc2query_deserializeOpModifyManagedResourceVisibility) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyManagedResourceVisibilityOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyLocalGatewayRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61080,79 +61840,7 @@ func (m *awsEc2query_deserializeOpModifyManagedResourceVisibility) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyManagedResourceVisibility(response *smithyhttp.Response, metadata *middleware.Metadata) error {
- var errorBuffer bytes.Buffer
- if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
- return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
- }
- errorBody := bytes.NewReader(errorBuffer.Bytes())
-
- errorCode := "UnknownError"
- errorMessage := errorCode
-
- errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
- if err != nil {
- return err
- }
- awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
- if len(errorComponents.Code) != 0 {
- errorCode = errorComponents.Code
- }
- if len(errorComponents.Message) != 0 {
- errorMessage = errorComponents.Message
- }
- errorBody.Seek(0, io.SeekStart)
- switch {
- default:
- genericError := &smithy.GenericAPIError{
- Code: errorCode,
- Message: errorMessage,
- }
- return genericError
-
- }
-}
-
-type awsEc2query_deserializeOpModifyNetworkInterfaceAttribute struct {
-}
-
-func (*awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) ID() string {
- return "OperationDeserializer"
-}
-
-func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
- out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
-) {
- out, metadata, err = next.HandleDeserialize(ctx, in)
- if err != nil {
- return out, metadata, err
- }
-
- _, span := tracing.StartSpan(ctx, "OperationDeserializer")
- endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
- defer endTimer()
- defer span.End()
- response, ok := out.RawResponse.(*smithyhttp.Response)
- if !ok {
- return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
- }
-
- if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response, &metadata)
- }
- output := &ModifyNetworkInterfaceAttributeOutput{}
- out.Result = output
-
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
- }
- }
-
- return out, metadata, err
-}
-
-func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyLocalGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61185,14 +61873,14 @@ func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smi
}
}
-type awsEc2query_deserializeOpModifyPrivateDnsNameOptions struct {
+type awsEc2query_deserializeOpModifyManagedPrefixList struct {
}
-func (*awsEc2query_deserializeOpModifyPrivateDnsNameOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyManagedPrefixList) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyManagedPrefixList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61210,9 +61898,9 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyManagedPrefixList(response, &metadata)
}
- output := &ModifyPrivateDnsNameOptionsOutput{}
+ output := &ModifyManagedPrefixListOutput{}
out.Result = output
var buff [1024]byte
@@ -61233,7 +61921,7 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyPrivateDnsNameOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyManagedPrefixListOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61247,7 +61935,7 @@ func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyManagedPrefixList(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61280,14 +61968,14 @@ func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response *smithyh
}
}
-type awsEc2query_deserializeOpModifyPublicIpDnsNameOptions struct {
+type awsEc2query_deserializeOpModifyManagedResourceVisibility struct {
}
-func (*awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyManagedResourceVisibility) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyManagedResourceVisibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61305,9 +61993,9 @@ func (m *awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyPublicIpDnsNameOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyManagedResourceVisibility(response, &metadata)
}
- output := &ModifyPublicIpDnsNameOptionsOutput{}
+ output := &ModifyManagedResourceVisibilityOutput{}
out.Result = output
var buff [1024]byte
@@ -61328,7 +62016,7 @@ func (m *awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyPublicIpDnsNameOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyManagedResourceVisibilityOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61342,7 +62030,7 @@ func (m *awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyPublicIpDnsNameOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyManagedResourceVisibility(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61375,14 +62063,14 @@ func awsEc2query_deserializeOpErrorModifyPublicIpDnsNameOptions(response *smithy
}
}
-type awsEc2query_deserializeOpModifyReservedInstances struct {
+type awsEc2query_deserializeOpModifyNetworkInterfaceAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyReservedInstances) ID() string {
+func (*awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyReservedInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61400,44 +62088,21 @@ func (m *awsEc2query_deserializeOpModifyReservedInstances) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyReservedInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response, &metadata)
}
- output := &ModifyReservedInstancesOutput{}
+ output := &ModifyNetworkInterfaceAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyReservedInstancesOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyReservedInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61470,14 +62135,14 @@ func awsEc2query_deserializeOpErrorModifyReservedInstances(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifyRouteServer struct {
+type awsEc2query_deserializeOpModifyPrivateDnsNameOptions struct {
}
-func (*awsEc2query_deserializeOpModifyRouteServer) ID() string {
+func (*awsEc2query_deserializeOpModifyPrivateDnsNameOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyPrivateDnsNameOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61495,9 +62160,9 @@ func (m *awsEc2query_deserializeOpModifyRouteServer) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyRouteServer(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response, &metadata)
}
- output := &ModifyRouteServerOutput{}
+ output := &ModifyPrivateDnsNameOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -61518,7 +62183,7 @@ func (m *awsEc2query_deserializeOpModifyRouteServer) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyRouteServerOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyPrivateDnsNameOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61532,7 +62197,7 @@ func (m *awsEc2query_deserializeOpModifyRouteServer) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyPrivateDnsNameOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61565,14 +62230,14 @@ func awsEc2query_deserializeOpErrorModifyRouteServer(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpModifySecurityGroupRules struct {
+type awsEc2query_deserializeOpModifyPublicIpDnsNameOptions struct {
}
-func (*awsEc2query_deserializeOpModifySecurityGroupRules) ID() string {
+func (*awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyPublicIpDnsNameOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61590,9 +62255,9 @@ func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifySecurityGroupRules(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyPublicIpDnsNameOptions(response, &metadata)
}
- output := &ModifySecurityGroupRulesOutput{}
+ output := &ModifyPublicIpDnsNameOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -61613,7 +62278,7 @@ func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifySecurityGroupRulesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyPublicIpDnsNameOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61627,7 +62292,7 @@ func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifySecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyPublicIpDnsNameOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61660,14 +62325,14 @@ func awsEc2query_deserializeOpErrorModifySecurityGroupRules(response *smithyhttp
}
}
-type awsEc2query_deserializeOpModifySnapshotAttribute struct {
+type awsEc2query_deserializeOpModifyReservedInstances struct {
}
-func (*awsEc2query_deserializeOpModifySnapshotAttribute) ID() string {
+func (*awsEc2query_deserializeOpModifyReservedInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifySnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyReservedInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61685,21 +62350,44 @@ func (m *awsEc2query_deserializeOpModifySnapshotAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyReservedInstances(response, &metadata)
}
- output := &ModifySnapshotAttributeOutput{}
+ output := &ModifyReservedInstancesOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentModifyReservedInstancesOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifySnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyReservedInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61732,14 +62420,14 @@ func awsEc2query_deserializeOpErrorModifySnapshotAttribute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpModifySnapshotTier struct {
+type awsEc2query_deserializeOpModifyRouteServer struct {
}
-func (*awsEc2query_deserializeOpModifySnapshotTier) ID() string {
+func (*awsEc2query_deserializeOpModifyRouteServer) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyRouteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61757,9 +62445,9 @@ func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotTier(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyRouteServer(response, &metadata)
}
- output := &ModifySnapshotTierOutput{}
+ output := &ModifyRouteServerOutput{}
out.Result = output
var buff [1024]byte
@@ -61780,7 +62468,7 @@ func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifySnapshotTierOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyRouteServerOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61794,7 +62482,7 @@ func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifySnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyRouteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61827,14 +62515,14 @@ func awsEc2query_deserializeOpErrorModifySnapshotTier(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpModifySpotFleetRequest struct {
+type awsEc2query_deserializeOpModifySecurityGroupRules struct {
}
-func (*awsEc2query_deserializeOpModifySpotFleetRequest) ID() string {
+func (*awsEc2query_deserializeOpModifySecurityGroupRules) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifySecurityGroupRules) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61852,9 +62540,9 @@ func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifySpotFleetRequest(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifySecurityGroupRules(response, &metadata)
}
- output := &ModifySpotFleetRequestOutput{}
+ output := &ModifySecurityGroupRulesOutput{}
out.Result = output
var buff [1024]byte
@@ -61875,7 +62563,7 @@ func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifySpotFleetRequestOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifySecurityGroupRulesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -61889,7 +62577,7 @@ func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifySpotFleetRequest(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifySecurityGroupRules(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61922,14 +62610,14 @@ func awsEc2query_deserializeOpErrorModifySpotFleetRequest(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpModifySubnetAttribute struct {
+type awsEc2query_deserializeOpModifySnapshotAttribute struct {
}
-func (*awsEc2query_deserializeOpModifySubnetAttribute) ID() string {
+func (*awsEc2query_deserializeOpModifySnapshotAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifySnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -61947,9 +62635,9 @@ func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifySubnetAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotAttribute(response, &metadata)
}
- output := &ModifySubnetAttributeOutput{}
+ output := &ModifySnapshotAttributeOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -61961,7 +62649,7 @@ func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifySubnetAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifySnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -61994,14 +62682,14 @@ func awsEc2query_deserializeOpErrorModifySubnetAttribute(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices struct {
+type awsEc2query_deserializeOpModifySnapshotTier struct {
}
-func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) ID() string {
+func (*awsEc2query_deserializeOpModifySnapshotTier) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifySnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62019,9 +62707,9 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) Hand
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifySnapshotTier(response, &metadata)
}
- output := &ModifyTrafficMirrorFilterNetworkServicesOutput{}
+ output := &ModifySnapshotTierOutput{}
out.Result = output
var buff [1024]byte
@@ -62042,7 +62730,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) Hand
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterNetworkServicesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifySnapshotTierOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62056,7 +62744,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) Hand
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifySnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62089,14 +62777,14 @@ func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(resp
}
}
-type awsEc2query_deserializeOpModifyTrafficMirrorFilterRule struct {
+type awsEc2query_deserializeOpModifySpotFleetRequest struct {
}
-func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) ID() string {
+func (*awsEc2query_deserializeOpModifySpotFleetRequest) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifySpotFleetRequest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62114,9 +62802,9 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifySpotFleetRequest(response, &metadata)
}
- output := &ModifyTrafficMirrorFilterRuleOutput{}
+ output := &ModifySpotFleetRequestOutput{}
out.Result = output
var buff [1024]byte
@@ -62137,7 +62825,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterRuleOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifySpotFleetRequestOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62151,7 +62839,7 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifySpotFleetRequest(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62184,14 +62872,14 @@ func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response *smith
}
}
-type awsEc2query_deserializeOpModifyTrafficMirrorSession struct {
+type awsEc2query_deserializeOpModifySubnetAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyTrafficMirrorSession) ID() string {
+func (*awsEc2query_deserializeOpModifySubnetAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifySubnetAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62209,44 +62897,21 @@ func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifySubnetAttribute(response, &metadata)
}
- output := &ModifyTrafficMirrorSessionOutput{}
+ output := &ModifySubnetAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorSessionOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifySubnetAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62279,14 +62944,14 @@ func awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response *smithyht
}
}
-type awsEc2query_deserializeOpModifyTransitGateway struct {
+type awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices struct {
}
-func (*awsEc2query_deserializeOpModifyTransitGateway) ID() string {
+func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterNetworkServices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62304,9 +62969,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGateway(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response, &metadata)
}
- output := &ModifyTransitGatewayOutput{}
+ output := &ModifyTrafficMirrorFilterNetworkServicesOutput{}
out.Result = output
var buff [1024]byte
@@ -62327,7 +62992,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTransitGatewayOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterNetworkServicesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62341,7 +63006,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterNetworkServices(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62374,14 +63039,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGateway(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy struct {
+type awsEc2query_deserializeOpModifyTrafficMirrorFilterRule struct {
}
-func (*awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) ID() string {
+func (*awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTrafficMirrorFilterRule) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62399,9 +63064,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayMeteringPolicy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response, &metadata)
}
- output := &ModifyTransitGatewayMeteringPolicyOutput{}
+ output := &ModifyTrafficMirrorFilterRuleOutput{}
out.Result = output
var buff [1024]byte
@@ -62422,7 +63087,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTransitGatewayMeteringPolicyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorFilterRuleOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62436,7 +63101,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTrafficMirrorFilterRule(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62469,14 +63134,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGatewayMeteringPolicy(response *
}
}
-type awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry struct {
+type awsEc2query_deserializeOpModifyTrafficMirrorSession struct {
}
-func (*awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) ID() string {
+func (*awsEc2query_deserializeOpModifyTrafficMirrorSession) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTrafficMirrorSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62494,9 +63159,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayPolicyTableEntry(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response, &metadata)
}
- output := &ModifyTransitGatewayPolicyTableEntryOutput{}
+ output := &ModifyTrafficMirrorSessionOutput{}
out.Result = output
var buff [1024]byte
@@ -62517,7 +63182,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTransitGatewayPolicyTableEntryOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTrafficMirrorSessionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62531,7 +63196,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTransitGatewayPolicyTableEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTrafficMirrorSession(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62564,14 +63229,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGatewayPolicyTableEntry(response
}
}
-type awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference struct {
+type awsEc2query_deserializeOpModifyTransitGateway struct {
}
-func (*awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) ID() string {
+func (*awsEc2query_deserializeOpModifyTransitGateway) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTransitGateway) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62589,9 +63254,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGateway(response, &metadata)
}
- output := &ModifyTransitGatewayPrefixListReferenceOutput{}
+ output := &ModifyTransitGatewayOutput{}
out.Result = output
var buff [1024]byte
@@ -62612,7 +63277,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTransitGatewayPrefixListReferenceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTransitGatewayOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62626,7 +63291,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTransitGateway(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62659,14 +63324,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(respo
}
}
-type awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment struct {
+type awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy struct {
}
-func (*awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) ID() string {
+func (*awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTransitGatewayMeteringPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62684,9 +63349,9 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayMeteringPolicy(response, &metadata)
}
- output := &ModifyTransitGatewayVpcAttachmentOutput{}
+ output := &ModifyTransitGatewayMeteringPolicyOutput{}
out.Result = output
var buff [1024]byte
@@ -62707,7 +63372,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyTransitGatewayVpcAttachmentOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTransitGatewayMeteringPolicyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62721,7 +63386,7 @@ func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTransitGatewayMeteringPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62754,14 +63419,14 @@ func awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response *s
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessEndpoint struct {
+type awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) ID() string {
+func (*awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTransitGatewayPolicyTableEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62779,9 +63444,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayPolicyTableEntry(response, &metadata)
}
- output := &ModifyVerifiedAccessEndpointOutput{}
+ output := &ModifyTransitGatewayPolicyTableEntryOutput{}
out.Result = output
var buff [1024]byte
@@ -62802,7 +63467,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTransitGatewayPolicyTableEntryOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62816,7 +63481,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTransitGatewayPolicyTableEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62849,14 +63514,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response *smithy
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy struct {
+type awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) ID() string {
+func (*awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTransitGatewayPrefixListReference) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62874,9 +63539,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDese
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response, &metadata)
}
- output := &ModifyVerifiedAccessEndpointPolicyOutput{}
+ output := &ModifyTransitGatewayPrefixListReferenceOutput{}
out.Result = output
var buff [1024]byte
@@ -62897,7 +63562,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDese
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointPolicyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTransitGatewayPrefixListReferenceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -62911,7 +63576,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDese
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTransitGatewayPrefixListReference(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -62944,14 +63609,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response *
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessGroup struct {
+type awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessGroup) ID() string {
+func (*awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -62969,9 +63634,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response, &metadata)
}
- output := &ModifyVerifiedAccessGroupOutput{}
+ output := &ModifyTransitGatewayVpcAttachmentOutput{}
out.Result = output
var buff [1024]byte
@@ -62992,7 +63657,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyTransitGatewayVpcAttachmentOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63006,7 +63671,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63039,14 +63704,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response *smithyhtt
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessEndpoint struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63064,9 +63729,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response, &metadata)
}
- output := &ModifyVerifiedAccessGroupPolicyOutput{}
+ output := &ModifyVerifiedAccessEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -63087,7 +63752,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupPolicyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63101,7 +63766,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63134,14 +63799,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response *smi
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessInstance struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessInstance) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessEndpointPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63159,9 +63824,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response, &metadata)
}
- output := &ModifyVerifiedAccessInstanceOutput{}
+ output := &ModifyVerifiedAccessEndpointPolicyOutput{}
out.Result = output
var buff [1024]byte
@@ -63182,7 +63847,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessEndpointPolicyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63196,7 +63861,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessEndpointPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63229,14 +63894,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response *smithy
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessGroup struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessGroup) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63254,9 +63919,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfigurati
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response, &metadata)
}
- output := &ModifyVerifiedAccessInstanceLoggingConfigurationOutput{}
+ output := &ModifyVerifiedAccessGroupOutput{}
out.Result = output
var buff [1024]byte
@@ -63277,7 +63942,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfigurati
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceLoggingConfigurationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63291,7 +63956,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfigurati
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroup(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63324,14 +63989,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfigurat
}
}
-type awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy struct {
}
-func (*awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessGroupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63349,9 +64014,9 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response, &metadata)
}
- output := &ModifyVerifiedAccessTrustProviderOutput{}
+ output := &ModifyVerifiedAccessGroupPolicyOutput{}
out.Result = output
var buff [1024]byte
@@ -63372,7 +64037,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessTrustProviderOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessGroupPolicyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63386,7 +64051,7 @@ func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessGroupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63419,14 +64084,14 @@ func awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response *s
}
}
-type awsEc2query_deserializeOpModifyVolume struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessInstance struct {
}
-func (*awsEc2query_deserializeOpModifyVolume) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessInstance) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63444,9 +64109,9 @@ func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVolume(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response, &metadata)
}
- output := &ModifyVolumeOutput{}
+ output := &ModifyVerifiedAccessInstanceOutput{}
out.Result = output
var buff [1024]byte
@@ -63467,7 +64132,7 @@ func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVolumeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63481,7 +64146,7 @@ func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63514,14 +64179,14 @@ func awsEc2query_deserializeOpErrorModifyVolume(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpModifyVolumeAttribute struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration struct {
}
-func (*awsEc2query_deserializeOpModifyVolumeAttribute) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessInstanceLoggingConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63539,93 +64204,44 @@ func (m *awsEc2query_deserializeOpModifyVolumeAttribute) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVolumeAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response, &metadata)
}
- output := &ModifyVolumeAttributeOutput{}
+ output := &ModifyVerifiedAccessInstanceLoggingConfigurationOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
- }
- }
-
- return out, metadata, err
-}
-
-func awsEc2query_deserializeOpErrorModifyVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
- var errorBuffer bytes.Buffer
- if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
- return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
}
- errorBody := bytes.NewReader(errorBuffer.Bytes())
-
- errorCode := "UnknownError"
- errorMessage := errorCode
-
- errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
if err != nil {
- return err
- }
- awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
- if len(errorComponents.Code) != 0 {
- errorCode = errorComponents.Code
- }
- if len(errorComponents.Message) != 0 {
- errorMessage = errorComponents.Message
- }
- errorBody.Seek(0, io.SeekStart)
- switch {
- default:
- genericError := &smithy.GenericAPIError{
- Code: errorCode,
- Message: errorMessage,
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
- return genericError
-
}
-}
-
-type awsEc2query_deserializeOpModifyVpcAttribute struct {
-}
-
-func (*awsEc2query_deserializeOpModifyVpcAttribute) ID() string {
- return "OperationDeserializer"
-}
-func (m *awsEc2query_deserializeOpModifyVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
- out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
-) {
- out, metadata, err = next.HandleDeserialize(ctx, in)
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessInstanceLoggingConfigurationOutput(&output, decoder)
if err != nil {
- return out, metadata, err
- }
-
- _, span := tracing.StartSpan(ctx, "OperationDeserializer")
- endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
- defer endTimer()
- defer span.End()
- response, ok := out.RawResponse.(*smithyhttp.Response)
- if !ok {
- return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
- }
-
- if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcAttribute(response, &metadata)
- }
- output := &ModifyVpcAttributeOutput{}
- out.Result = output
-
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessInstanceLoggingConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63658,14 +64274,14 @@ func awsEc2query_deserializeOpErrorModifyVpcAttribute(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion struct {
+type awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider struct {
}
-func (*awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) ID() string {
+func (*awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVerifiedAccessTrustProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63683,9 +64299,9 @@ func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessExclusion(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response, &metadata)
}
- output := &ModifyVpcBlockPublicAccessExclusionOutput{}
+ output := &ModifyVerifiedAccessTrustProviderOutput{}
out.Result = output
var buff [1024]byte
@@ -63706,7 +64322,7 @@ func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcBlockPublicAccessExclusionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVerifiedAccessTrustProviderOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63720,7 +64336,7 @@ func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessExclusion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVerifiedAccessTrustProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63753,14 +64369,14 @@ func awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessExclusion(response
}
}
-type awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions struct {
+type awsEc2query_deserializeOpModifyVolume struct {
}
-func (*awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyVolume) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVolume) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63778,9 +64394,9 @@ func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVolume(response, &metadata)
}
- output := &ModifyVpcBlockPublicAccessOptionsOutput{}
+ output := &ModifyVolumeOutput{}
out.Result = output
var buff [1024]byte
@@ -63801,7 +64417,7 @@ func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcBlockPublicAccessOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVolumeOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -63815,7 +64431,7 @@ func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVolume(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63848,14 +64464,14 @@ func awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessOptions(response *s
}
}
-type awsEc2query_deserializeOpModifyVpcEncryptionControl struct {
+type awsEc2query_deserializeOpModifyVolumeAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEncryptionControl) ID() string {
+func (*awsEc2query_deserializeOpModifyVolumeAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEncryptionControl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVolumeAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63873,44 +64489,21 @@ func (m *awsEc2query_deserializeOpModifyVpcEncryptionControl) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEncryptionControl(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVolumeAttribute(response, &metadata)
}
- output := &ModifyVpcEncryptionControlOutput{}
+ output := &ModifyVolumeAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEncryptionControlOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEncryptionControl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVolumeAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -63943,14 +64536,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEncryptionControl(response *smithyht
}
}
-type awsEc2query_deserializeOpModifyVpcEndpoint struct {
+type awsEc2query_deserializeOpModifyVpcAttribute struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEndpoint) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -63968,44 +64561,21 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpoint) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpoint(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcAttribute(response, &metadata)
}
- output := &ModifyVpcEndpointOutput{}
+ output := &ModifyVpcAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEndpointOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64038,14 +64608,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpoint(response *smithyhttp.Respon
}
}
-type awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification struct {
+type awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessExclusion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64063,9 +64633,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessExclusion(response, &metadata)
}
- output := &ModifyVpcEndpointConnectionNotificationOutput{}
+ output := &ModifyVpcBlockPublicAccessExclusionOutput{}
out.Result = output
var buff [1024]byte
@@ -64086,7 +64656,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEndpointConnectionNotificationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcBlockPublicAccessExclusionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64100,7 +64670,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessExclusion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64133,14 +64703,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(respo
}
}
-type awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility struct {
+type awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcBlockPublicAccessOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64158,9 +64728,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointPayerResponsibility(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessOptions(response, &metadata)
}
- output := &ModifyVpcEndpointPayerResponsibilityOutput{}
+ output := &ModifyVpcBlockPublicAccessOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -64181,7 +64751,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEndpointPayerResponsibilityOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcBlockPublicAccessOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64195,7 +64765,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEndpointPayerResponsibility(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcBlockPublicAccessOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64228,14 +64798,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointPayerResponsibility(response
}
}
-type awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration struct {
+type awsEc2query_deserializeOpModifyVpcEncryptionControl struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEncryptionControl) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEncryptionControl) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64253,9 +64823,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEncryptionControl(response, &metadata)
}
- output := &ModifyVpcEndpointServiceConfigurationOutput{}
+ output := &ModifyVpcEncryptionControlOutput{}
out.Result = output
var buff [1024]byte
@@ -64276,7 +64846,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServiceConfigurationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEncryptionControlOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64290,7 +64860,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEncryptionControl(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64323,14 +64893,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(respons
}
}
-type awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility struct {
+type awsEc2query_deserializeOpModifyVpcEndpoint struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEndpoint) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEndpoint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64348,9 +64918,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpoint(response, &metadata)
}
- output := &ModifyVpcEndpointServicePayerResponsibilityOutput{}
+ output := &ModifyVpcEndpointOutput{}
out.Result = output
var buff [1024]byte
@@ -64371,7 +64941,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePayerResponsibilityOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEndpointOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64385,7 +64955,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEndpoint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64418,14 +64988,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(r
}
}
-type awsEc2query_deserializeOpModifyVpcEndpointServicePermissions struct {
+type awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification struct {
}
-func (*awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEndpointConnectionNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64443,9 +65013,9 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response, &metadata)
}
- output := &ModifyVpcEndpointServicePermissionsOutput{}
+ output := &ModifyVpcEndpointConnectionNotificationOutput{}
out.Result = output
var buff [1024]byte
@@ -64466,7 +65036,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePermissionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEndpointConnectionNotificationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64480,7 +65050,7 @@ func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEndpointConnectionNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64513,14 +65083,14 @@ func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response
}
}
-type awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions struct {
+type awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility struct {
}
-func (*awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEndpointPayerResponsibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64538,9 +65108,9 @@ func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointPayerResponsibility(response, &metadata)
}
- output := &ModifyVpcPeeringConnectionOptionsOutput{}
+ output := &ModifyVpcEndpointPayerResponsibilityOutput{}
out.Result = output
var buff [1024]byte
@@ -64561,7 +65131,7 @@ func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcPeeringConnectionOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEndpointPayerResponsibilityOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64575,7 +65145,7 @@ func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEndpointPayerResponsibility(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64608,14 +65178,14 @@ func awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response *s
}
}
-type awsEc2query_deserializeOpModifyVpcTenancy struct {
+type awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration struct {
}
-func (*awsEc2query_deserializeOpModifyVpcTenancy) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEndpointServiceConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64633,9 +65203,9 @@ func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpcTenancy(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response, &metadata)
}
- output := &ModifyVpcTenancyOutput{}
+ output := &ModifyVpcEndpointServiceConfigurationOutput{}
out.Result = output
var buff [1024]byte
@@ -64656,7 +65226,7 @@ func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpcTenancyOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServiceConfigurationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64670,7 +65240,7 @@ func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpcTenancy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEndpointServiceConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64703,14 +65273,14 @@ func awsEc2query_deserializeOpErrorModifyVpcTenancy(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpModifyVpnConnection struct {
+type awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility struct {
}
-func (*awsEc2query_deserializeOpModifyVpnConnection) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePayerResponsibility) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64728,9 +65298,9 @@ func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnection(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response, &metadata)
}
- output := &ModifyVpnConnectionOutput{}
+ output := &ModifyVpcEndpointServicePayerResponsibilityOutput{}
out.Result = output
var buff [1024]byte
@@ -64751,7 +65321,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePayerResponsibilityOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64765,7 +65335,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePayerResponsibility(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64798,14 +65368,14 @@ func awsEc2query_deserializeOpErrorModifyVpnConnection(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpModifyVpnConnectionOptions struct {
+type awsEc2query_deserializeOpModifyVpcEndpointServicePermissions struct {
}
-func (*awsEc2query_deserializeOpModifyVpnConnectionOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcEndpointServicePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64823,9 +65393,9 @@ func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response, &metadata)
}
- output := &ModifyVpnConnectionOptionsOutput{}
+ output := &ModifyVpcEndpointServicePermissionsOutput{}
out.Result = output
var buff [1024]byte
@@ -64846,7 +65416,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcEndpointServicePermissionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64860,7 +65430,7 @@ func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcEndpointServicePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64893,14 +65463,14 @@ func awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response *smithyht
}
}
-type awsEc2query_deserializeOpModifyVpnTunnelCertificate struct {
+type awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions struct {
}
-func (*awsEc2query_deserializeOpModifyVpnTunnelCertificate) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcPeeringConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -64918,9 +65488,9 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response, &metadata)
}
- output := &ModifyVpnTunnelCertificateOutput{}
+ output := &ModifyVpcPeeringConnectionOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -64941,7 +65511,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpnTunnelCertificateOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcPeeringConnectionOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -64955,7 +65525,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcPeeringConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -64988,14 +65558,14 @@ func awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response *smithyht
}
}
-type awsEc2query_deserializeOpModifyVpnTunnelOptions struct {
+type awsEc2query_deserializeOpModifyVpcTenancy struct {
}
-func (*awsEc2query_deserializeOpModifyVpnTunnelOptions) ID() string {
+func (*awsEc2query_deserializeOpModifyVpcTenancy) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpcTenancy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65013,9 +65583,9 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpcTenancy(response, &metadata)
}
- output := &ModifyVpnTunnelOptionsOutput{}
+ output := &ModifyVpcTenancyOutput{}
out.Result = output
var buff [1024]byte
@@ -65036,7 +65606,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentModifyVpnTunnelOptionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpcTenancyOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65050,7 +65620,7 @@ func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpcTenancy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65083,14 +65653,14 @@ func awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpMonitorInstances struct {
+type awsEc2query_deserializeOpModifyVpnConnection struct {
}
-func (*awsEc2query_deserializeOpMonitorInstances) ID() string {
+func (*awsEc2query_deserializeOpModifyVpnConnection) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpnConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65108,9 +65678,9 @@ func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorMonitorInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnection(response, &metadata)
}
- output := &MonitorInstancesOutput{}
+ output := &ModifyVpnConnectionOutput{}
out.Result = output
var buff [1024]byte
@@ -65131,7 +65701,7 @@ func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentMonitorInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65145,7 +65715,7 @@ func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorMonitorInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpnConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65178,14 +65748,14 @@ func awsEc2query_deserializeOpErrorMonitorInstances(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpMoveAddressToVpc struct {
+type awsEc2query_deserializeOpModifyVpnConnectionOptions struct {
}
-func (*awsEc2query_deserializeOpMoveAddressToVpc) ID() string {
+func (*awsEc2query_deserializeOpModifyVpnConnectionOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpnConnectionOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65203,9 +65773,9 @@ func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorMoveAddressToVpc(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response, &metadata)
}
- output := &MoveAddressToVpcOutput{}
+ output := &ModifyVpnConnectionOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -65226,7 +65796,7 @@ func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentMoveAddressToVpcOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpnConnectionOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65240,7 +65810,7 @@ func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorMoveAddressToVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpnConnectionOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65273,14 +65843,14 @@ func awsEc2query_deserializeOpErrorMoveAddressToVpc(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpMoveByoipCidrToIpam struct {
+type awsEc2query_deserializeOpModifyVpnTunnelCertificate struct {
}
-func (*awsEc2query_deserializeOpMoveByoipCidrToIpam) ID() string {
+func (*awsEc2query_deserializeOpModifyVpnTunnelCertificate) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpnTunnelCertificate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65298,9 +65868,9 @@ func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response, &metadata)
}
- output := &MoveByoipCidrToIpamOutput{}
+ output := &ModifyVpnTunnelCertificateOutput{}
out.Result = output
var buff [1024]byte
@@ -65321,7 +65891,7 @@ func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentMoveByoipCidrToIpamOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpnTunnelCertificateOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65335,7 +65905,7 @@ func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpnTunnelCertificate(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65368,14 +65938,14 @@ func awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpMoveCapacityReservationInstances struct {
+type awsEc2query_deserializeOpModifyVpnTunnelOptions struct {
}
-func (*awsEc2query_deserializeOpMoveCapacityReservationInstances) ID() string {
+func (*awsEc2query_deserializeOpModifyVpnTunnelOptions) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpMoveCapacityReservationInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpModifyVpnTunnelOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65393,9 +65963,9 @@ func (m *awsEc2query_deserializeOpMoveCapacityReservationInstances) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorMoveCapacityReservationInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response, &metadata)
}
- output := &MoveCapacityReservationInstancesOutput{}
+ output := &ModifyVpnTunnelOptionsOutput{}
out.Result = output
var buff [1024]byte
@@ -65416,7 +65986,7 @@ func (m *awsEc2query_deserializeOpMoveCapacityReservationInstances) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentMoveCapacityReservationInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentModifyVpnTunnelOptionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65430,7 +66000,7 @@ func (m *awsEc2query_deserializeOpMoveCapacityReservationInstances) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorMoveCapacityReservationInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorModifyVpnTunnelOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65463,14 +66033,14 @@ func awsEc2query_deserializeOpErrorMoveCapacityReservationInstances(response *sm
}
}
-type awsEc2query_deserializeOpProvisionByoipCidr struct {
+type awsEc2query_deserializeOpMonitorInstances struct {
}
-func (*awsEc2query_deserializeOpProvisionByoipCidr) ID() string {
+func (*awsEc2query_deserializeOpMonitorInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpMonitorInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65488,9 +66058,9 @@ func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorProvisionByoipCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorMonitorInstances(response, &metadata)
}
- output := &ProvisionByoipCidrOutput{}
+ output := &MonitorInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -65511,7 +66081,7 @@ func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentProvisionByoipCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentMonitorInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65525,7 +66095,7 @@ func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorMonitorInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65558,14 +66128,14 @@ func awsEc2query_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpProvisionIpamByoasn struct {
+type awsEc2query_deserializeOpMoveAddressToVpc struct {
}
-func (*awsEc2query_deserializeOpProvisionIpamByoasn) ID() string {
+func (*awsEc2query_deserializeOpMoveAddressToVpc) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpProvisionIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpMoveAddressToVpc) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65583,9 +66153,9 @@ func (m *awsEc2query_deserializeOpProvisionIpamByoasn) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorProvisionIpamByoasn(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorMoveAddressToVpc(response, &metadata)
}
- output := &ProvisionIpamByoasnOutput{}
+ output := &MoveAddressToVpcOutput{}
out.Result = output
var buff [1024]byte
@@ -65606,7 +66176,7 @@ func (m *awsEc2query_deserializeOpProvisionIpamByoasn) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentProvisionIpamByoasnOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentMoveAddressToVpcOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65620,7 +66190,7 @@ func (m *awsEc2query_deserializeOpProvisionIpamByoasn) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorProvisionIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorMoveAddressToVpc(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65653,14 +66223,14 @@ func awsEc2query_deserializeOpErrorProvisionIpamByoasn(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpProvisionIpamPoolCidr struct {
+type awsEc2query_deserializeOpMoveByoipCidrToIpam struct {
}
-func (*awsEc2query_deserializeOpProvisionIpamPoolCidr) ID() string {
+func (*awsEc2query_deserializeOpMoveByoipCidrToIpam) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpMoveByoipCidrToIpam) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65678,9 +66248,9 @@ func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response, &metadata)
}
- output := &ProvisionIpamPoolCidrOutput{}
+ output := &MoveByoipCidrToIpamOutput{}
out.Result = output
var buff [1024]byte
@@ -65701,7 +66271,7 @@ func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentProvisionIpamPoolCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentMoveByoipCidrToIpamOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65715,7 +66285,7 @@ func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorMoveByoipCidrToIpam(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65748,14 +66318,14 @@ func awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr struct {
+type awsEc2query_deserializeOpMoveCapacityReservationInstances struct {
}
-func (*awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) ID() string {
+func (*awsEc2query_deserializeOpMoveCapacityReservationInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpMoveCapacityReservationInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65773,9 +66343,9 @@ func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorMoveCapacityReservationInstances(response, &metadata)
}
- output := &ProvisionPublicIpv4PoolCidrOutput{}
+ output := &MoveCapacityReservationInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -65796,7 +66366,7 @@ func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentProvisionPublicIpv4PoolCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentMoveCapacityReservationInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65810,7 +66380,7 @@ func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorMoveCapacityReservationInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65843,14 +66413,14 @@ func awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response *smithyh
}
}
-type awsEc2query_deserializeOpPurchaseCapacityBlock struct {
+type awsEc2query_deserializeOpProvisionByoipCidr struct {
}
-func (*awsEc2query_deserializeOpPurchaseCapacityBlock) ID() string {
+func (*awsEc2query_deserializeOpProvisionByoipCidr) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpPurchaseCapacityBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpProvisionByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65868,9 +66438,9 @@ func (m *awsEc2query_deserializeOpPurchaseCapacityBlock) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorPurchaseCapacityBlock(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorProvisionByoipCidr(response, &metadata)
}
- output := &PurchaseCapacityBlockOutput{}
+ output := &ProvisionByoipCidrOutput{}
out.Result = output
var buff [1024]byte
@@ -65891,7 +66461,7 @@ func (m *awsEc2query_deserializeOpPurchaseCapacityBlock) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentPurchaseCapacityBlockOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentProvisionByoipCidrOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -65905,7 +66475,7 @@ func (m *awsEc2query_deserializeOpPurchaseCapacityBlock) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorPurchaseCapacityBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorProvisionByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -65938,14 +66508,14 @@ func awsEc2query_deserializeOpErrorPurchaseCapacityBlock(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpPurchaseCapacityBlockExtension struct {
+type awsEc2query_deserializeOpProvisionIpamByoasn struct {
}
-func (*awsEc2query_deserializeOpPurchaseCapacityBlockExtension) ID() string {
+func (*awsEc2query_deserializeOpProvisionIpamByoasn) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpPurchaseCapacityBlockExtension) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpProvisionIpamByoasn) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -65963,9 +66533,9 @@ func (m *awsEc2query_deserializeOpPurchaseCapacityBlockExtension) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorPurchaseCapacityBlockExtension(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorProvisionIpamByoasn(response, &metadata)
}
- output := &PurchaseCapacityBlockExtensionOutput{}
+ output := &ProvisionIpamByoasnOutput{}
out.Result = output
var buff [1024]byte
@@ -65986,7 +66556,7 @@ func (m *awsEc2query_deserializeOpPurchaseCapacityBlockExtension) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentPurchaseCapacityBlockExtensionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentProvisionIpamByoasnOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66000,7 +66570,7 @@ func (m *awsEc2query_deserializeOpPurchaseCapacityBlockExtension) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorPurchaseCapacityBlockExtension(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorProvisionIpamByoasn(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66033,14 +66603,14 @@ func awsEc2query_deserializeOpErrorPurchaseCapacityBlockExtension(response *smit
}
}
-type awsEc2query_deserializeOpPurchaseHostReservation struct {
+type awsEc2query_deserializeOpProvisionIpamPoolCidr struct {
}
-func (*awsEc2query_deserializeOpPurchaseHostReservation) ID() string {
+func (*awsEc2query_deserializeOpProvisionIpamPoolCidr) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpProvisionIpamPoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66058,9 +66628,9 @@ func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorPurchaseHostReservation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response, &metadata)
}
- output := &PurchaseHostReservationOutput{}
+ output := &ProvisionIpamPoolCidrOutput{}
out.Result = output
var buff [1024]byte
@@ -66081,7 +66651,7 @@ func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentPurchaseHostReservationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentProvisionIpamPoolCidrOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66095,7 +66665,7 @@ func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorPurchaseHostReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorProvisionIpamPoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66128,14 +66698,14 @@ func awsEc2query_deserializeOpErrorPurchaseHostReservation(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpPurchaseReservedInstancesOffering struct {
+type awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr struct {
}
-func (*awsEc2query_deserializeOpPurchaseReservedInstancesOffering) ID() string {
+func (*awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpProvisionPublicIpv4PoolCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66153,9 +66723,9 @@ func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response, &metadata)
}
- output := &PurchaseReservedInstancesOfferingOutput{}
+ output := &ProvisionPublicIpv4PoolCidrOutput{}
out.Result = output
var buff [1024]byte
@@ -66176,7 +66746,7 @@ func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentPurchaseReservedInstancesOfferingOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentProvisionPublicIpv4PoolCidrOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66190,7 +66760,7 @@ func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorProvisionPublicIpv4PoolCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66223,14 +66793,14 @@ func awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response *s
}
}
-type awsEc2query_deserializeOpPurchaseScheduledInstances struct {
+type awsEc2query_deserializeOpPurchaseCapacityBlock struct {
}
-func (*awsEc2query_deserializeOpPurchaseScheduledInstances) ID() string {
+func (*awsEc2query_deserializeOpPurchaseCapacityBlock) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpPurchaseCapacityBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66248,9 +66818,9 @@ func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorPurchaseCapacityBlock(response, &metadata)
}
- output := &PurchaseScheduledInstancesOutput{}
+ output := &PurchaseCapacityBlockOutput{}
out.Result = output
var buff [1024]byte
@@ -66271,7 +66841,7 @@ func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentPurchaseScheduledInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentPurchaseCapacityBlockOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66285,79 +66855,7 @@ func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
- var errorBuffer bytes.Buffer
- if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
- return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
- }
- errorBody := bytes.NewReader(errorBuffer.Bytes())
-
- errorCode := "UnknownError"
- errorMessage := errorCode
-
- errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
- if err != nil {
- return err
- }
- awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
- if len(errorComponents.Code) != 0 {
- errorCode = errorComponents.Code
- }
- if len(errorComponents.Message) != 0 {
- errorMessage = errorComponents.Message
- }
- errorBody.Seek(0, io.SeekStart)
- switch {
- default:
- genericError := &smithy.GenericAPIError{
- Code: errorCode,
- Message: errorMessage,
- }
- return genericError
-
- }
-}
-
-type awsEc2query_deserializeOpRebootInstances struct {
-}
-
-func (*awsEc2query_deserializeOpRebootInstances) ID() string {
- return "OperationDeserializer"
-}
-
-func (m *awsEc2query_deserializeOpRebootInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
- out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
-) {
- out, metadata, err = next.HandleDeserialize(ctx, in)
- if err != nil {
- return out, metadata, err
- }
-
- _, span := tracing.StartSpan(ctx, "OperationDeserializer")
- endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
- defer endTimer()
- defer span.End()
- response, ok := out.RawResponse.(*smithyhttp.Response)
- if !ok {
- return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
- }
-
- if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRebootInstances(response, &metadata)
- }
- output := &RebootInstancesOutput{}
- out.Result = output
-
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
- return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
- }
- }
-
- return out, metadata, err
-}
-
-func awsEc2query_deserializeOpErrorRebootInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorPurchaseCapacityBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66390,14 +66888,14 @@ func awsEc2query_deserializeOpErrorRebootInstances(response *smithyhttp.Response
}
}
-type awsEc2query_deserializeOpRegisterImage struct {
+type awsEc2query_deserializeOpPurchaseCapacityBlockExtension struct {
}
-func (*awsEc2query_deserializeOpRegisterImage) ID() string {
+func (*awsEc2query_deserializeOpPurchaseCapacityBlockExtension) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpPurchaseCapacityBlockExtension) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66415,9 +66913,9 @@ func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRegisterImage(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorPurchaseCapacityBlockExtension(response, &metadata)
}
- output := &RegisterImageOutput{}
+ output := &PurchaseCapacityBlockExtensionOutput{}
out.Result = output
var buff [1024]byte
@@ -66438,7 +66936,7 @@ func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRegisterImageOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentPurchaseCapacityBlockExtensionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66452,7 +66950,7 @@ func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRegisterImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorPurchaseCapacityBlockExtension(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66485,14 +66983,14 @@ func awsEc2query_deserializeOpErrorRegisterImage(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes struct {
+type awsEc2query_deserializeOpPurchaseHostReservation struct {
}
-func (*awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) ID() string {
+func (*awsEc2query_deserializeOpPurchaseHostReservation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpPurchaseHostReservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66510,9 +67008,9 @@ func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorPurchaseHostReservation(response, &metadata)
}
- output := &RegisterInstanceEventNotificationAttributesOutput{}
+ output := &PurchaseHostReservationOutput{}
out.Result = output
var buff [1024]byte
@@ -66533,7 +67031,7 @@ func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRegisterInstanceEventNotificationAttributesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentPurchaseHostReservationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66547,7 +67045,7 @@ func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorPurchaseHostReservation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66580,14 +67078,14 @@ func awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(r
}
}
-type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers struct {
+type awsEc2query_deserializeOpPurchaseReservedInstancesOffering struct {
}
-func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) ID() string {
+func (*awsEc2query_deserializeOpPurchaseReservedInstancesOffering) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpPurchaseReservedInstancesOffering) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66605,9 +67103,9 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response, &metadata)
}
- output := &RegisterTransitGatewayMulticastGroupMembersOutput{}
+ output := &PurchaseReservedInstancesOfferingOutput{}
out.Result = output
var buff [1024]byte
@@ -66628,7 +67126,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupMembersOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentPurchaseReservedInstancesOfferingOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66642,7 +67140,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorPurchaseReservedInstancesOffering(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66675,14 +67173,14 @@ func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(r
}
}
-type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources struct {
+type awsEc2query_deserializeOpPurchaseScheduledInstances struct {
}
-func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) ID() string {
+func (*awsEc2query_deserializeOpPurchaseScheduledInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpPurchaseScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66700,9 +67198,9 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response, &metadata)
}
- output := &RegisterTransitGatewayMulticastGroupSourcesOutput{}
+ output := &PurchaseScheduledInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -66723,7 +67221,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupSourcesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentPurchaseScheduledInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66737,7 +67235,7 @@ func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorPurchaseScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66770,14 +67268,14 @@ func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(r
}
}
-type awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership struct {
+type awsEc2query_deserializeOpRebootInstances struct {
}
-func (*awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership) ID() string {
+func (*awsEc2query_deserializeOpRebootInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRebootInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66795,44 +67293,21 @@ func (m *awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership) Han
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectCapacityReservationBillingOwnership(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRebootInstances(response, &metadata)
}
- output := &RejectCapacityReservationBillingOwnershipOutput{}
+ output := &RebootInstancesOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectCapacityReservationBillingOwnershipOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectCapacityReservationBillingOwnership(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRebootInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66865,14 +67340,14 @@ func awsEc2query_deserializeOpErrorRejectCapacityReservationBillingOwnership(res
}
}
-type awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment struct {
+type awsEc2query_deserializeOpRegisterImage struct {
}
-func (*awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) ID() string {
+func (*awsEc2query_deserializeOpRegisterImage) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRegisterImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66890,9 +67365,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayClientVpnAttachment(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRegisterImage(response, &metadata)
}
- output := &RejectTransitGatewayClientVpnAttachmentOutput{}
+ output := &RegisterImageOutput{}
out.Result = output
var buff [1024]byte
@@ -66913,7 +67388,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectTransitGatewayClientVpnAttachmentOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRegisterImageOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -66927,7 +67402,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectTransitGatewayClientVpnAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRegisterImage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -66960,14 +67435,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayClientVpnAttachment(respo
}
}
-type awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations struct {
+type awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes struct {
}
-func (*awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) ID() string {
+func (*awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRegisterInstanceEventNotificationAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -66985,9 +67460,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociation
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response, &metadata)
}
- output := &RejectTransitGatewayMulticastDomainAssociationsOutput{}
+ output := &RegisterInstanceEventNotificationAttributesOutput{}
out.Result = output
var buff [1024]byte
@@ -67008,7 +67483,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociation
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectTransitGatewayMulticastDomainAssociationsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRegisterInstanceEventNotificationAttributesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67022,7 +67497,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociation
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRegisterInstanceEventNotificationAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67055,14 +67530,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociatio
}
}
-type awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment struct {
+type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers struct {
}
-func (*awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) ID() string {
+func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupMembers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67080,9 +67555,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response, &metadata)
}
- output := &RejectTransitGatewayPeeringAttachmentOutput{}
+ output := &RegisterTransitGatewayMulticastGroupMembersOutput{}
out.Result = output
var buff [1024]byte
@@ -67103,7 +67578,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectTransitGatewayPeeringAttachmentOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupMembersOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67117,7 +67592,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupMembers(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67150,14 +67625,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(respons
}
}
-type awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment struct {
+type awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources struct {
}
-func (*awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) ID() string {
+func (*awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRegisterTransitGatewayMulticastGroupSources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67175,9 +67650,9 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeser
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response, &metadata)
}
- output := &RejectTransitGatewayVpcAttachmentOutput{}
+ output := &RegisterTransitGatewayMulticastGroupSourcesOutput{}
out.Result = output
var buff [1024]byte
@@ -67198,7 +67673,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeser
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectTransitGatewayVpcAttachmentOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRegisterTransitGatewayMulticastGroupSourcesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67212,7 +67687,7 @@ func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeser
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRegisterTransitGatewayMulticastGroupSources(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67245,14 +67720,14 @@ func awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response *s
}
}
-type awsEc2query_deserializeOpRejectVpcEndpointConnections struct {
+type awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership struct {
}
-func (*awsEc2query_deserializeOpRejectVpcEndpointConnections) ID() string {
+func (*awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectCapacityReservationBillingOwnership) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67270,9 +67745,9 @@ func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectCapacityReservationBillingOwnership(response, &metadata)
}
- output := &RejectVpcEndpointConnectionsOutput{}
+ output := &RejectCapacityReservationBillingOwnershipOutput{}
out.Result = output
var buff [1024]byte
@@ -67293,7 +67768,7 @@ func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectVpcEndpointConnectionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRejectCapacityReservationBillingOwnershipOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67307,7 +67782,7 @@ func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectCapacityReservationBillingOwnership(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67340,14 +67815,14 @@ func awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response *smithy
}
}
-type awsEc2query_deserializeOpRejectVpcPeeringConnection struct {
+type awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment struct {
}
-func (*awsEc2query_deserializeOpRejectVpcPeeringConnection) ID() string {
+func (*awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectTransitGatewayClientVpnAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67365,9 +67840,9 @@ func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayClientVpnAttachment(response, &metadata)
}
- output := &RejectVpcPeeringConnectionOutput{}
+ output := &RejectTransitGatewayClientVpnAttachmentOutput{}
out.Result = output
var buff [1024]byte
@@ -67388,7 +67863,7 @@ func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRejectVpcPeeringConnectionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRejectTransitGatewayClientVpnAttachmentOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67402,7 +67877,7 @@ func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectTransitGatewayClientVpnAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67435,14 +67910,14 @@ func awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response *smithyht
}
}
-type awsEc2query_deserializeOpReleaseAddress struct {
+type awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations struct {
}
-func (*awsEc2query_deserializeOpReleaseAddress) ID() string {
+func (*awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReleaseAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectTransitGatewayMulticastDomainAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67460,21 +67935,44 @@ func (m *awsEc2query_deserializeOpReleaseAddress) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReleaseAddress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response, &metadata)
}
- output := &ReleaseAddressOutput{}
+ output := &RejectTransitGatewayMulticastDomainAssociationsOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentRejectTransitGatewayMulticastDomainAssociationsOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReleaseAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectTransitGatewayMulticastDomainAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67507,14 +68005,14 @@ func awsEc2query_deserializeOpErrorReleaseAddress(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpReleaseHosts struct {
+type awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment struct {
}
-func (*awsEc2query_deserializeOpReleaseHosts) ID() string {
+func (*awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectTransitGatewayPeeringAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67532,9 +68030,9 @@ func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReleaseHosts(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response, &metadata)
}
- output := &ReleaseHostsOutput{}
+ output := &RejectTransitGatewayPeeringAttachmentOutput{}
out.Result = output
var buff [1024]byte
@@ -67555,7 +68053,7 @@ func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReleaseHostsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRejectTransitGatewayPeeringAttachmentOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67569,7 +68067,7 @@ func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReleaseHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectTransitGatewayPeeringAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67602,14 +68100,14 @@ func awsEc2query_deserializeOpErrorReleaseHosts(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpReleaseIpamPoolAllocation struct {
+type awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment struct {
}
-func (*awsEc2query_deserializeOpReleaseIpamPoolAllocation) ID() string {
+func (*awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectTransitGatewayVpcAttachment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67627,9 +68125,9 @@ func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response, &metadata)
}
- output := &ReleaseIpamPoolAllocationOutput{}
+ output := &RejectTransitGatewayVpcAttachmentOutput{}
out.Result = output
var buff [1024]byte
@@ -67650,7 +68148,7 @@ func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReleaseIpamPoolAllocationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRejectTransitGatewayVpcAttachmentOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67664,7 +68162,7 @@ func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectTransitGatewayVpcAttachment(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67697,14 +68195,14 @@ func awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response *smithyhtt
}
}
-type awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation struct {
+type awsEc2query_deserializeOpRejectVpcEndpointConnections struct {
}
-func (*awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) ID() string {
+func (*awsEc2query_deserializeOpRejectVpcEndpointConnections) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectVpcEndpointConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67722,9 +68220,9 @@ func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDe
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response, &metadata)
}
- output := &ReplaceIamInstanceProfileAssociationOutput{}
+ output := &RejectVpcEndpointConnectionsOutput{}
out.Result = output
var buff [1024]byte
@@ -67745,7 +68243,7 @@ func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDe
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReplaceIamInstanceProfileAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRejectVpcEndpointConnectionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67759,7 +68257,7 @@ func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDe
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectVpcEndpointConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67792,14 +68290,14 @@ func awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response
}
}
-type awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings struct {
+type awsEc2query_deserializeOpRejectVpcPeeringConnection struct {
}
-func (*awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) ID() string {
+func (*awsEc2query_deserializeOpRejectVpcPeeringConnection) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRejectVpcPeeringConnection) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67817,9 +68315,9 @@ func (m *awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) H
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceImageCriteriaInAllowedImagesSettings(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response, &metadata)
}
- output := &ReplaceImageCriteriaInAllowedImagesSettingsOutput{}
+ output := &RejectVpcPeeringConnectionOutput{}
out.Result = output
var buff [1024]byte
@@ -67840,7 +68338,7 @@ func (m *awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) H
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReplaceImageCriteriaInAllowedImagesSettingsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRejectVpcPeeringConnectionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67854,7 +68352,7 @@ func (m *awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) H
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceImageCriteriaInAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRejectVpcPeeringConnection(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67887,14 +68385,14 @@ func awsEc2query_deserializeOpErrorReplaceImageCriteriaInAllowedImagesSettings(r
}
}
-type awsEc2query_deserializeOpReplaceNetworkAclAssociation struct {
+type awsEc2query_deserializeOpReleaseAddress struct {
}
-func (*awsEc2query_deserializeOpReplaceNetworkAclAssociation) ID() string {
+func (*awsEc2query_deserializeOpReleaseAddress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReleaseAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -67912,9 +68410,81 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReleaseAddress(response, &metadata)
}
- output := &ReplaceNetworkAclAssociationOutput{}
+ output := &ReleaseAddressOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorReleaseAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpReleaseHosts struct {
+}
+
+func (*awsEc2query_deserializeOpReleaseHosts) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpReleaseHosts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorReleaseHosts(response, &metadata)
+ }
+ output := &ReleaseHostsOutput{}
out.Result = output
var buff [1024]byte
@@ -67935,7 +68505,7 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReplaceNetworkAclAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentReleaseHostsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -67949,7 +68519,7 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReleaseHosts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -67982,14 +68552,14 @@ func awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response *smithy
}
}
-type awsEc2query_deserializeOpReplaceNetworkAclEntry struct {
+type awsEc2query_deserializeOpReleaseIpamPoolAllocation struct {
}
-func (*awsEc2query_deserializeOpReplaceNetworkAclEntry) ID() string {
+func (*awsEc2query_deserializeOpReleaseIpamPoolAllocation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReleaseIpamPoolAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68007,21 +68577,44 @@ func (m *awsEc2query_deserializeOpReplaceNetworkAclEntry) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response, &metadata)
}
- output := &ReplaceNetworkAclEntryOutput{}
+ output := &ReleaseIpamPoolAllocationOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentReleaseIpamPoolAllocationOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReleaseIpamPoolAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68054,14 +68647,14 @@ func awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpReplaceRoute struct {
+type awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation struct {
}
-func (*awsEc2query_deserializeOpReplaceRoute) ID() string {
+func (*awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceIamInstanceProfileAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68079,21 +68672,44 @@ func (m *awsEc2query_deserializeOpReplaceRoute) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response, &metadata)
}
- output := &ReplaceRouteOutput{}
+ output := &ReplaceIamInstanceProfileAssociationOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentReplaceIamInstanceProfileAssociationOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceIamInstanceProfileAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68126,14 +68742,14 @@ func awsEc2query_deserializeOpErrorReplaceRoute(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpReplaceRouteTableAssociation struct {
+type awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings struct {
}
-func (*awsEc2query_deserializeOpReplaceRouteTableAssociation) ID() string {
+func (*awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceImageCriteriaInAllowedImagesSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68151,9 +68767,9 @@ func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceImageCriteriaInAllowedImagesSettings(response, &metadata)
}
- output := &ReplaceRouteTableAssociationOutput{}
+ output := &ReplaceImageCriteriaInAllowedImagesSettingsOutput{}
out.Result = output
var buff [1024]byte
@@ -68174,7 +68790,7 @@ func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReplaceRouteTableAssociationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentReplaceImageCriteriaInAllowedImagesSettingsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68188,7 +68804,7 @@ func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceImageCriteriaInAllowedImagesSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68221,14 +68837,14 @@ func awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response *smithy
}
}
-type awsEc2query_deserializeOpReplaceTransitGatewayRoute struct {
+type awsEc2query_deserializeOpReplaceNetworkAclAssociation struct {
}
-func (*awsEc2query_deserializeOpReplaceTransitGatewayRoute) ID() string {
+func (*awsEc2query_deserializeOpReplaceNetworkAclAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceNetworkAclAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68246,9 +68862,9 @@ func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response, &metadata)
}
- output := &ReplaceTransitGatewayRouteOutput{}
+ output := &ReplaceNetworkAclAssociationOutput{}
out.Result = output
var buff [1024]byte
@@ -68269,7 +68885,7 @@ func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReplaceTransitGatewayRouteOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentReplaceNetworkAclAssociationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68283,7 +68899,7 @@ func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceNetworkAclAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68316,14 +68932,14 @@ func awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response *smithyht
}
}
-type awsEc2query_deserializeOpReplaceVpnTunnel struct {
+type awsEc2query_deserializeOpReplaceNetworkAclEntry struct {
}
-func (*awsEc2query_deserializeOpReplaceVpnTunnel) ID() string {
+func (*awsEc2query_deserializeOpReplaceNetworkAclEntry) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReplaceVpnTunnel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceNetworkAclEntry) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68341,44 +68957,21 @@ func (m *awsEc2query_deserializeOpReplaceVpnTunnel) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReplaceVpnTunnel(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response, &metadata)
}
- output := &ReplaceVpnTunnelOutput{}
+ output := &ReplaceNetworkAclEntryOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentReplaceVpnTunnelOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReplaceVpnTunnel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceNetworkAclEntry(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68411,14 +69004,14 @@ func awsEc2query_deserializeOpErrorReplaceVpnTunnel(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpReportInstanceStatus struct {
+type awsEc2query_deserializeOpReplaceRoute struct {
}
-func (*awsEc2query_deserializeOpReportInstanceStatus) ID() string {
+func (*awsEc2query_deserializeOpReplaceRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68436,9 +69029,9 @@ func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorReportInstanceStatus(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceRoute(response, &metadata)
}
- output := &ReportInstanceStatusOutput{}
+ output := &ReplaceRouteOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -68450,7 +69043,7 @@ func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorReportInstanceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68483,14 +69076,14 @@ func awsEc2query_deserializeOpErrorReportInstanceStatus(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpRequestSpotFleet struct {
+type awsEc2query_deserializeOpReplaceRouteTableAssociation struct {
}
-func (*awsEc2query_deserializeOpRequestSpotFleet) ID() string {
+func (*awsEc2query_deserializeOpReplaceRouteTableAssociation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceRouteTableAssociation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68508,9 +69101,9 @@ func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx contex
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRequestSpotFleet(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response, &metadata)
}
- output := &RequestSpotFleetOutput{}
+ output := &ReplaceRouteTableAssociationOutput{}
out.Result = output
var buff [1024]byte
@@ -68531,7 +69124,7 @@ func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx contex
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRequestSpotFleetOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentReplaceRouteTableAssociationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68545,7 +69138,7 @@ func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx contex
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRequestSpotFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceRouteTableAssociation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68578,14 +69171,14 @@ func awsEc2query_deserializeOpErrorRequestSpotFleet(response *smithyhttp.Respons
}
}
-type awsEc2query_deserializeOpRequestSpotInstances struct {
+type awsEc2query_deserializeOpReplaceTransitGatewayRoute struct {
}
-func (*awsEc2query_deserializeOpRequestSpotInstances) ID() string {
+func (*awsEc2query_deserializeOpReplaceTransitGatewayRoute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceTransitGatewayRoute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68603,9 +69196,9 @@ func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRequestSpotInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response, &metadata)
}
- output := &RequestSpotInstancesOutput{}
+ output := &ReplaceTransitGatewayRouteOutput{}
out.Result = output
var buff [1024]byte
@@ -68626,7 +69219,7 @@ func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRequestSpotInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentReplaceTransitGatewayRouteOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68640,7 +69233,7 @@ func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRequestSpotInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceTransitGatewayRoute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68673,14 +69266,14 @@ func awsEc2query_deserializeOpErrorRequestSpotInstances(response *smithyhttp.Res
}
}
-type awsEc2query_deserializeOpResetAddressAttribute struct {
+type awsEc2query_deserializeOpReplaceVpnTunnel struct {
}
-func (*awsEc2query_deserializeOpResetAddressAttribute) ID() string {
+func (*awsEc2query_deserializeOpReplaceVpnTunnel) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReplaceVpnTunnel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68698,9 +69291,9 @@ func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetAddressAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReplaceVpnTunnel(response, &metadata)
}
- output := &ResetAddressAttributeOutput{}
+ output := &ReplaceVpnTunnelOutput{}
out.Result = output
var buff [1024]byte
@@ -68721,7 +69314,7 @@ func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentResetAddressAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentReplaceVpnTunnelOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68735,7 +69328,7 @@ func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetAddressAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorReplaceVpnTunnel(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68768,14 +69361,14 @@ func awsEc2query_deserializeOpErrorResetAddressAttribute(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpResetEbsDefaultKmsKeyId struct {
+type awsEc2query_deserializeOpReportInstanceStatus struct {
}
-func (*awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) ID() string {
+func (*awsEc2query_deserializeOpReportInstanceStatus) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpReportInstanceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68793,9 +69386,81 @@ func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorReportInstanceStatus(response, &metadata)
}
- output := &ResetEbsDefaultKmsKeyIdOutput{}
+ output := &ReportInstanceStatusOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorReportInstanceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpRequestSpotFleet struct {
+}
+
+func (*awsEc2query_deserializeOpRequestSpotFleet) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpRequestSpotFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorRequestSpotFleet(response, &metadata)
+ }
+ output := &RequestSpotFleetOutput{}
out.Result = output
var buff [1024]byte
@@ -68816,7 +69481,7 @@ func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentResetEbsDefaultKmsKeyIdOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRequestSpotFleetOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68830,7 +69495,7 @@ func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRequestSpotFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68863,14 +69528,14 @@ func awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpResetFpgaImageAttribute struct {
+type awsEc2query_deserializeOpRequestSpotInstances struct {
}
-func (*awsEc2query_deserializeOpResetFpgaImageAttribute) ID() string {
+func (*awsEc2query_deserializeOpRequestSpotInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRequestSpotInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68888,9 +69553,9 @@ func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRequestSpotInstances(response, &metadata)
}
- output := &ResetFpgaImageAttributeOutput{}
+ output := &RequestSpotInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -68911,7 +69576,7 @@ func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentResetFpgaImageAttributeOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRequestSpotInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -68925,7 +69590,7 @@ func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRequestSpotInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -68958,14 +69623,14 @@ func awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpResetImageAttribute struct {
+type awsEc2query_deserializeOpResetAddressAttribute struct {
}
-func (*awsEc2query_deserializeOpResetImageAttribute) ID() string {
+func (*awsEc2query_deserializeOpResetAddressAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpResetAddressAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -68983,21 +69648,44 @@ func (m *awsEc2query_deserializeOpResetImageAttribute) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetImageAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorResetAddressAttribute(response, &metadata)
}
- output := &ResetImageAttributeOutput{}
+ output := &ResetAddressAttributeOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentResetAddressAttributeOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorResetAddressAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69030,14 +69718,14 @@ func awsEc2query_deserializeOpErrorResetImageAttribute(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpResetInstanceAttribute struct {
+type awsEc2query_deserializeOpResetEbsDefaultKmsKeyId struct {
}
-func (*awsEc2query_deserializeOpResetInstanceAttribute) ID() string {
+func (*awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpResetEbsDefaultKmsKeyId) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69055,21 +69743,44 @@ func (m *awsEc2query_deserializeOpResetInstanceAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetInstanceAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response, &metadata)
}
- output := &ResetInstanceAttributeOutput{}
+ output := &ResetEbsDefaultKmsKeyIdOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentResetEbsDefaultKmsKeyIdOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorResetEbsDefaultKmsKeyId(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69102,14 +69813,14 @@ func awsEc2query_deserializeOpErrorResetInstanceAttribute(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpResetNetworkInterfaceAttribute struct {
+type awsEc2query_deserializeOpResetFpgaImageAttribute struct {
}
-func (*awsEc2query_deserializeOpResetNetworkInterfaceAttribute) ID() string {
+func (*awsEc2query_deserializeOpResetFpgaImageAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpResetFpgaImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69127,21 +69838,44 @@ func (m *awsEc2query_deserializeOpResetNetworkInterfaceAttribute) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response, &metadata)
}
- output := &ResetNetworkInterfaceAttributeOutput{}
+ output := &ResetFpgaImageAttributeOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentResetFpgaImageAttributeOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorResetFpgaImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69174,14 +69908,14 @@ func awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response *smit
}
}
-type awsEc2query_deserializeOpResetSnapshotAttribute struct {
+type awsEc2query_deserializeOpResetImageAttribute struct {
}
-func (*awsEc2query_deserializeOpResetSnapshotAttribute) ID() string {
+func (*awsEc2query_deserializeOpResetImageAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpResetImageAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69199,9 +69933,9 @@ func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorResetSnapshotAttribute(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorResetImageAttribute(response, &metadata)
}
- output := &ResetSnapshotAttributeOutput{}
+ output := &ResetImageAttributeOutput{}
out.Result = output
if _, err = io.Copy(io.Discard, response.Body); err != nil {
@@ -69213,7 +69947,7 @@ func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorResetSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorResetImageAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69246,14 +69980,14 @@ func awsEc2query_deserializeOpErrorResetSnapshotAttribute(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpRestoreAddressToClassic struct {
+type awsEc2query_deserializeOpResetInstanceAttribute struct {
}
-func (*awsEc2query_deserializeOpRestoreAddressToClassic) ID() string {
+func (*awsEc2query_deserializeOpResetInstanceAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRestoreAddressToClassic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpResetInstanceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69271,44 +70005,21 @@ func (m *awsEc2query_deserializeOpRestoreAddressToClassic) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRestoreAddressToClassic(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorResetInstanceAttribute(response, &metadata)
}
- output := &RestoreAddressToClassicOutput{}
+ output := &ResetInstanceAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRestoreAddressToClassicOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRestoreAddressToClassic(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorResetInstanceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69341,14 +70052,14 @@ func awsEc2query_deserializeOpErrorRestoreAddressToClassic(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpRestoreImageFromRecycleBin struct {
+type awsEc2query_deserializeOpResetNetworkInterfaceAttribute struct {
}
-func (*awsEc2query_deserializeOpRestoreImageFromRecycleBin) ID() string {
+func (*awsEc2query_deserializeOpResetNetworkInterfaceAttribute) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRestoreImageFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpResetNetworkInterfaceAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69366,44 +70077,93 @@ func (m *awsEc2query_deserializeOpRestoreImageFromRecycleBin) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response, &metadata)
}
- output := &RestoreImageFromRecycleBinOutput{}
+ output := &ResetNetworkInterfaceAttributeOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
}
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRestoreImageFromRecycleBinOutput(&output, decoder)
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorResetNetworkInterfaceAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
}
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpResetSnapshotAttribute struct {
+}
+
+func (*awsEc2query_deserializeOpResetSnapshotAttribute) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpResetSnapshotAttribute) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
return out, metadata, err
}
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorResetSnapshotAttribute(response, &metadata)
+ }
+ output := &ResetSnapshotAttributeOutput{}
+ out.Result = output
+
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to discard response body, %w", err),
+ }
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorResetSnapshotAttribute(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69436,14 +70196,14 @@ func awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response *smithyht
}
}
-type awsEc2query_deserializeOpRestoreManagedPrefixListVersion struct {
+type awsEc2query_deserializeOpRestoreAddressToClassic struct {
}
-func (*awsEc2query_deserializeOpRestoreManagedPrefixListVersion) ID() string {
+func (*awsEc2query_deserializeOpRestoreAddressToClassic) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRestoreAddressToClassic) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69461,9 +70221,9 @@ func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeseria
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRestoreAddressToClassic(response, &metadata)
}
- output := &RestoreManagedPrefixListVersionOutput{}
+ output := &RestoreAddressToClassicOutput{}
out.Result = output
var buff [1024]byte
@@ -69484,7 +70244,7 @@ func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeseria
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRestoreManagedPrefixListVersionOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRestoreAddressToClassicOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -69498,7 +70258,7 @@ func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeseria
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRestoreAddressToClassic(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69531,14 +70291,14 @@ func awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response *smi
}
}
-type awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin struct {
+type awsEc2query_deserializeOpRestoreImageFromRecycleBin struct {
}
-func (*awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) ID() string {
+func (*awsEc2query_deserializeOpRestoreImageFromRecycleBin) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRestoreImageFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69556,9 +70316,9 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response, &metadata)
}
- output := &RestoreSnapshotFromRecycleBinOutput{}
+ output := &RestoreImageFromRecycleBinOutput{}
out.Result = output
var buff [1024]byte
@@ -69579,7 +70339,7 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRestoreSnapshotFromRecycleBinOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRestoreImageFromRecycleBinOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -69593,7 +70353,7 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRestoreImageFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69626,14 +70386,14 @@ func awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response *smith
}
}
-type awsEc2query_deserializeOpRestoreSnapshotTier struct {
+type awsEc2query_deserializeOpRestoreManagedPrefixListVersion struct {
}
-func (*awsEc2query_deserializeOpRestoreSnapshotTier) ID() string {
+func (*awsEc2query_deserializeOpRestoreManagedPrefixListVersion) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRestoreManagedPrefixListVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69651,9 +70411,9 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx con
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotTier(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response, &metadata)
}
- output := &RestoreSnapshotTierOutput{}
+ output := &RestoreManagedPrefixListVersionOutput{}
out.Result = output
var buff [1024]byte
@@ -69674,7 +70434,7 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx con
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRestoreSnapshotTierOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRestoreManagedPrefixListVersionOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -69688,7 +70448,7 @@ func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx con
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRestoreSnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRestoreManagedPrefixListVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69721,14 +70481,14 @@ func awsEc2query_deserializeOpErrorRestoreSnapshotTier(response *smithyhttp.Resp
}
}
-type awsEc2query_deserializeOpRestoreVolumeFromRecycleBin struct {
+type awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin struct {
}
-func (*awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) ID() string {
+func (*awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRestoreSnapshotFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69746,9 +70506,9 @@ func (m *awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) HandleDeserialize
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRestoreVolumeFromRecycleBin(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response, &metadata)
}
- output := &RestoreVolumeFromRecycleBinOutput{}
+ output := &RestoreSnapshotFromRecycleBinOutput{}
out.Result = output
var buff [1024]byte
@@ -69769,7 +70529,7 @@ func (m *awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) HandleDeserialize
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRestoreVolumeFromRecycleBinOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRestoreSnapshotFromRecycleBinOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -69783,7 +70543,7 @@ func (m *awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) HandleDeserialize
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRestoreVolumeFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRestoreSnapshotFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69816,14 +70576,14 @@ func awsEc2query_deserializeOpErrorRestoreVolumeFromRecycleBin(response *smithyh
}
}
-type awsEc2query_deserializeOpRevokeClientVpnIngress struct {
+type awsEc2query_deserializeOpRestoreSnapshotTier struct {
}
-func (*awsEc2query_deserializeOpRevokeClientVpnIngress) ID() string {
+func (*awsEc2query_deserializeOpRestoreSnapshotTier) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRestoreSnapshotTier) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69841,9 +70601,9 @@ func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRestoreSnapshotTier(response, &metadata)
}
- output := &RevokeClientVpnIngressOutput{}
+ output := &RestoreSnapshotTierOutput{}
out.Result = output
var buff [1024]byte
@@ -69864,7 +70624,7 @@ func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRevokeClientVpnIngressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRestoreSnapshotTierOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -69878,7 +70638,7 @@ func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRestoreSnapshotTier(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -69911,14 +70671,14 @@ func awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response *smithyhttp.R
}
}
-type awsEc2query_deserializeOpRevokeSecurityGroupEgress struct {
+type awsEc2query_deserializeOpRestoreVolumeFromRecycleBin struct {
}
-func (*awsEc2query_deserializeOpRevokeSecurityGroupEgress) ID() string {
+func (*awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRestoreVolumeFromRecycleBin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -69936,9 +70696,9 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRestoreVolumeFromRecycleBin(response, &metadata)
}
- output := &RevokeSecurityGroupEgressOutput{}
+ output := &RestoreVolumeFromRecycleBinOutput{}
out.Result = output
var buff [1024]byte
@@ -69959,7 +70719,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupEgressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRestoreVolumeFromRecycleBinOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -69973,7 +70733,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRestoreVolumeFromRecycleBin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70006,14 +70766,14 @@ func awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response *smithyhtt
}
}
-type awsEc2query_deserializeOpRevokeSecurityGroupIngress struct {
+type awsEc2query_deserializeOpRevokeClientVpnIngress struct {
}
-func (*awsEc2query_deserializeOpRevokeSecurityGroupIngress) ID() string {
+func (*awsEc2query_deserializeOpRevokeClientVpnIngress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRevokeClientVpnIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70031,9 +70791,9 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response, &metadata)
}
- output := &RevokeSecurityGroupIngressOutput{}
+ output := &RevokeClientVpnIngressOutput{}
out.Result = output
var buff [1024]byte
@@ -70054,7 +70814,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupIngressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRevokeClientVpnIngressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70068,7 +70828,7 @@ func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRevokeClientVpnIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70101,14 +70861,14 @@ func awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response *smithyht
}
}
-type awsEc2query_deserializeOpRunInstances struct {
+type awsEc2query_deserializeOpRevokeSecurityGroupEgress struct {
}
-func (*awsEc2query_deserializeOpRunInstances) ID() string {
+func (*awsEc2query_deserializeOpRevokeSecurityGroupEgress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRevokeSecurityGroupEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70126,9 +70886,9 @@ func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Co
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRunInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response, &metadata)
}
- output := &RunInstancesOutput{}
+ output := &RevokeSecurityGroupEgressOutput{}
out.Result = output
var buff [1024]byte
@@ -70149,7 +70909,7 @@ func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Co
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRunInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupEgressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70163,7 +70923,7 @@ func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Co
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRunInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRevokeSecurityGroupEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70196,14 +70956,14 @@ func awsEc2query_deserializeOpErrorRunInstances(response *smithyhttp.Response, m
}
}
-type awsEc2query_deserializeOpRunScheduledInstances struct {
+type awsEc2query_deserializeOpRevokeSecurityGroupIngress struct {
}
-func (*awsEc2query_deserializeOpRunScheduledInstances) ID() string {
+func (*awsEc2query_deserializeOpRevokeSecurityGroupIngress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRevokeSecurityGroupIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70221,9 +70981,9 @@ func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorRunScheduledInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response, &metadata)
}
- output := &RunScheduledInstancesOutput{}
+ output := &RevokeSecurityGroupIngressOutput{}
out.Result = output
var buff [1024]byte
@@ -70244,7 +71004,7 @@ func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentRunScheduledInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRevokeSecurityGroupIngressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70258,7 +71018,7 @@ func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorRunScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRevokeSecurityGroupIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70291,14 +71051,14 @@ func awsEc2query_deserializeOpErrorRunScheduledInstances(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpSearchLocalGatewayRoutes struct {
+type awsEc2query_deserializeOpRunInstances struct {
}
-func (*awsEc2query_deserializeOpSearchLocalGatewayRoutes) ID() string {
+func (*awsEc2query_deserializeOpRunInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRunInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70316,9 +71076,9 @@ func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ct
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRunInstances(response, &metadata)
}
- output := &SearchLocalGatewayRoutesOutput{}
+ output := &RunInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -70339,7 +71099,7 @@ func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ct
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentSearchLocalGatewayRoutesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRunInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70353,7 +71113,7 @@ func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ct
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRunInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70386,14 +71146,14 @@ func awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response *smithyhttp
}
}
-type awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups struct {
+type awsEc2query_deserializeOpRunScheduledInstances struct {
}
-func (*awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) ID() string {
+func (*awsEc2query_deserializeOpRunScheduledInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpRunScheduledInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70411,9 +71171,9 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDes
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorRunScheduledInstances(response, &metadata)
}
- output := &SearchTransitGatewayMulticastGroupsOutput{}
+ output := &RunScheduledInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -70434,7 +71194,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDes
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentSearchTransitGatewayMulticastGroupsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentRunScheduledInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70448,7 +71208,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDes
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorRunScheduledInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70481,14 +71241,14 @@ func awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response
}
}
-type awsEc2query_deserializeOpSearchTransitGatewayRoutes struct {
+type awsEc2query_deserializeOpSearchLocalGatewayRoutes struct {
}
-func (*awsEc2query_deserializeOpSearchTransitGatewayRoutes) ID() string {
+func (*awsEc2query_deserializeOpSearchLocalGatewayRoutes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpSearchLocalGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70506,9 +71266,9 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response, &metadata)
}
- output := &SearchTransitGatewayRoutesOutput{}
+ output := &SearchLocalGatewayRoutesOutput{}
out.Result = output
var buff [1024]byte
@@ -70529,7 +71289,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentSearchTransitGatewayRoutesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentSearchLocalGatewayRoutesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70543,7 +71303,7 @@ func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorSearchLocalGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70576,14 +71336,14 @@ func awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response *smithyht
}
}
-type awsEc2query_deserializeOpSendDiagnosticInterrupt struct {
+type awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups struct {
}
-func (*awsEc2query_deserializeOpSendDiagnosticInterrupt) ID() string {
+func (*awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpSendDiagnosticInterrupt) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpSearchTransitGatewayMulticastGroups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70601,21 +71361,44 @@ func (m *awsEc2query_deserializeOpSendDiagnosticInterrupt) HandleDeserialize(ctx
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response, &metadata)
}
- output := &SendDiagnosticInterruptOutput{}
+ output := &SearchTransitGatewayMulticastGroupsOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentSearchTransitGatewayMulticastGroupsOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
+ return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorSearchTransitGatewayMulticastGroups(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70648,14 +71431,14 @@ func awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response *smithyhttp.
}
}
-type awsEc2query_deserializeOpStartDeclarativePoliciesReport struct {
+type awsEc2query_deserializeOpSearchTransitGatewayRoutes struct {
}
-func (*awsEc2query_deserializeOpStartDeclarativePoliciesReport) ID() string {
+func (*awsEc2query_deserializeOpSearchTransitGatewayRoutes) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpStartDeclarativePoliciesReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpSearchTransitGatewayRoutes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70673,9 +71456,9 @@ func (m *awsEc2query_deserializeOpStartDeclarativePoliciesReport) HandleDeserial
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorStartDeclarativePoliciesReport(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response, &metadata)
}
- output := &StartDeclarativePoliciesReportOutput{}
+ output := &SearchTransitGatewayRoutesOutput{}
out.Result = output
var buff [1024]byte
@@ -70696,7 +71479,7 @@ func (m *awsEc2query_deserializeOpStartDeclarativePoliciesReport) HandleDeserial
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentStartDeclarativePoliciesReportOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentSearchTransitGatewayRoutesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70710,7 +71493,7 @@ func (m *awsEc2query_deserializeOpStartDeclarativePoliciesReport) HandleDeserial
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorStartDeclarativePoliciesReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorSearchTransitGatewayRoutes(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70743,14 +71526,14 @@ func awsEc2query_deserializeOpErrorStartDeclarativePoliciesReport(response *smit
}
}
-type awsEc2query_deserializeOpStartInstances struct {
+type awsEc2query_deserializeOpSendDiagnosticInterrupt struct {
}
-func (*awsEc2query_deserializeOpStartInstances) ID() string {
+func (*awsEc2query_deserializeOpSendDiagnosticInterrupt) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpSendDiagnosticInterrupt) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70768,44 +71551,21 @@ func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorStartInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response, &metadata)
}
- output := &StartInstancesOutput{}
+ output := &SendDiagnosticInterruptOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentStartInstancesOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorStartInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorSendDiagnosticInterrupt(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70838,14 +71598,14 @@ func awsEc2query_deserializeOpErrorStartInstances(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis struct {
+type awsEc2query_deserializeOpStartDeclarativePoliciesReport struct {
}
-func (*awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) ID() string {
+func (*awsEc2query_deserializeOpStartDeclarativePoliciesReport) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpStartDeclarativePoliciesReport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70863,9 +71623,9 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) Handl
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorStartDeclarativePoliciesReport(response, &metadata)
}
- output := &StartNetworkInsightsAccessScopeAnalysisOutput{}
+ output := &StartDeclarativePoliciesReportOutput{}
out.Result = output
var buff [1024]byte
@@ -70886,7 +71646,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) Handl
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAccessScopeAnalysisOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentStartDeclarativePoliciesReportOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70900,7 +71660,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) Handl
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorStartDeclarativePoliciesReport(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -70933,14 +71693,14 @@ func awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(respo
}
}
-type awsEc2query_deserializeOpStartNetworkInsightsAnalysis struct {
+type awsEc2query_deserializeOpStartInstances struct {
}
-func (*awsEc2query_deserializeOpStartNetworkInsightsAnalysis) ID() string {
+func (*awsEc2query_deserializeOpStartInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpStartInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -70958,9 +71718,9 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserializ
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorStartInstances(response, &metadata)
}
- output := &StartNetworkInsightsAnalysisOutput{}
+ output := &StartInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -70981,7 +71741,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserializ
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAnalysisOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentStartInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -70995,7 +71755,7 @@ func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserializ
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorStartInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71028,14 +71788,14 @@ func awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response *smithy
}
}
-type awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification struct {
+type awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis struct {
}
-func (*awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) ID() string {
+func (*awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpStartNetworkInsightsAccessScopeAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71053,9 +71813,9 @@ func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification)
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response, &metadata)
}
- output := &StartVpcEndpointServicePrivateDnsVerificationOutput{}
+ output := &StartNetworkInsightsAccessScopeAnalysisOutput{}
out.Result = output
var buff [1024]byte
@@ -71076,7 +71836,7 @@ func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification)
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentStartVpcEndpointServicePrivateDnsVerificationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAccessScopeAnalysisOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71090,7 +71850,7 @@ func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification)
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorStartNetworkInsightsAccessScopeAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71123,14 +71883,14 @@ func awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification
}
}
-type awsEc2query_deserializeOpStopInstances struct {
+type awsEc2query_deserializeOpStartNetworkInsightsAnalysis struct {
}
-func (*awsEc2query_deserializeOpStopInstances) ID() string {
+func (*awsEc2query_deserializeOpStartNetworkInsightsAnalysis) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpStartNetworkInsightsAnalysis) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71148,9 +71908,9 @@ func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.C
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorStopInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response, &metadata)
}
- output := &StopInstancesOutput{}
+ output := &StartNetworkInsightsAnalysisOutput{}
out.Result = output
var buff [1024]byte
@@ -71171,7 +71931,7 @@ func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.C
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentStopInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentStartNetworkInsightsAnalysisOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71185,7 +71945,7 @@ func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.C
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorStopInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorStartNetworkInsightsAnalysis(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71218,14 +71978,14 @@ func awsEc2query_deserializeOpErrorStopInstances(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpTerminateClientVpnConnections struct {
+type awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification struct {
}
-func (*awsEc2query_deserializeOpTerminateClientVpnConnections) ID() string {
+func (*awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpStartVpcEndpointServicePrivateDnsVerification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71243,9 +72003,9 @@ func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeseriali
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response, &metadata)
}
- output := &TerminateClientVpnConnectionsOutput{}
+ output := &StartVpcEndpointServicePrivateDnsVerificationOutput{}
out.Result = output
var buff [1024]byte
@@ -71266,7 +72026,7 @@ func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeseriali
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentTerminateClientVpnConnectionsOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentStartVpcEndpointServicePrivateDnsVerificationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71280,7 +72040,7 @@ func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeseriali
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorStartVpcEndpointServicePrivateDnsVerification(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71313,14 +72073,14 @@ func awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response *smith
}
}
-type awsEc2query_deserializeOpTerminateInstances struct {
+type awsEc2query_deserializeOpStopInstances struct {
}
-func (*awsEc2query_deserializeOpTerminateInstances) ID() string {
+func (*awsEc2query_deserializeOpStopInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpStopInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71338,9 +72098,9 @@ func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorTerminateInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorStopInstances(response, &metadata)
}
- output := &TerminateInstancesOutput{}
+ output := &StopInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -71361,7 +72121,7 @@ func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentTerminateInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentStopInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71375,7 +72135,7 @@ func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorTerminateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorStopInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71408,14 +72168,14 @@ func awsEc2query_deserializeOpErrorTerminateInstances(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpUnassignIpv6Addresses struct {
+type awsEc2query_deserializeOpTerminateClientVpnConnections struct {
}
-func (*awsEc2query_deserializeOpUnassignIpv6Addresses) ID() string {
+func (*awsEc2query_deserializeOpTerminateClientVpnConnections) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUnassignIpv6Addresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpTerminateClientVpnConnections) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71433,9 +72193,9 @@ func (m *awsEc2query_deserializeOpUnassignIpv6Addresses) HandleDeserialize(ctx c
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUnassignIpv6Addresses(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response, &metadata)
}
- output := &UnassignIpv6AddressesOutput{}
+ output := &TerminateClientVpnConnectionsOutput{}
out.Result = output
var buff [1024]byte
@@ -71456,7 +72216,7 @@ func (m *awsEc2query_deserializeOpUnassignIpv6Addresses) HandleDeserialize(ctx c
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUnassignIpv6AddressesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentTerminateClientVpnConnectionsOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71470,7 +72230,7 @@ func (m *awsEc2query_deserializeOpUnassignIpv6Addresses) HandleDeserialize(ctx c
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUnassignIpv6Addresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorTerminateClientVpnConnections(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71503,14 +72263,14 @@ func awsEc2query_deserializeOpErrorUnassignIpv6Addresses(response *smithyhttp.Re
}
}
-type awsEc2query_deserializeOpUnassignPrivateIpAddresses struct {
+type awsEc2query_deserializeOpTerminateInstances struct {
}
-func (*awsEc2query_deserializeOpUnassignPrivateIpAddresses) ID() string {
+func (*awsEc2query_deserializeOpTerminateInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUnassignPrivateIpAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpTerminateInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71528,21 +72288,44 @@ func (m *awsEc2query_deserializeOpUnassignPrivateIpAddresses) HandleDeserialize(
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUnassignPrivateIpAddresses(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorTerminateInstances(response, &metadata)
}
- output := &UnassignPrivateIpAddressesOutput{}
+ output := &TerminateInstancesOutput{}
out.Result = output
- if _, err = io.Copy(io.Discard, response.Body); err != nil {
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to discard response body, %w", err),
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
}
}
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentTerminateInstancesOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUnassignPrivateIpAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorTerminateInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71575,14 +72358,14 @@ func awsEc2query_deserializeOpErrorUnassignPrivateIpAddresses(response *smithyht
}
}
-type awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress struct {
+type awsEc2query_deserializeOpUnassignIpv6Addresses struct {
}
-func (*awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) ID() string {
+func (*awsEc2query_deserializeOpUnassignIpv6Addresses) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUnassignIpv6Addresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71600,9 +72383,9 @@ func (m *awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) HandleDeseri
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUnassignPrivateNatGatewayAddress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUnassignIpv6Addresses(response, &metadata)
}
- output := &UnassignPrivateNatGatewayAddressOutput{}
+ output := &UnassignIpv6AddressesOutput{}
out.Result = output
var buff [1024]byte
@@ -71623,7 +72406,7 @@ func (m *awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) HandleDeseri
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUnassignPrivateNatGatewayAddressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUnassignIpv6AddressesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71637,7 +72420,7 @@ func (m *awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) HandleDeseri
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUnassignPrivateNatGatewayAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUnassignIpv6Addresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71670,14 +72453,14 @@ func awsEc2query_deserializeOpErrorUnassignPrivateNatGatewayAddress(response *sm
}
}
-type awsEc2query_deserializeOpUnlockSnapshot struct {
+type awsEc2query_deserializeOpUnassignPrivateIpAddresses struct {
}
-func (*awsEc2query_deserializeOpUnlockSnapshot) ID() string {
+func (*awsEc2query_deserializeOpUnassignPrivateIpAddresses) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUnlockSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUnassignPrivateIpAddresses) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71695,44 +72478,21 @@ func (m *awsEc2query_deserializeOpUnlockSnapshot) HandleDeserialize(ctx context.
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUnlockSnapshot(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUnassignPrivateIpAddresses(response, &metadata)
}
- output := &UnlockSnapshotOutput{}
+ output := &UnassignPrivateIpAddressesOutput{}
out.Result = output
- var buff [1024]byte
- ringBuffer := smithyio.NewRingBuffer(buff[:])
- body := io.TeeReader(response.Body, ringBuffer)
- rootDecoder := xml.NewDecoder(body)
- t, err := smithyxml.FetchRootElement(rootDecoder)
- if err == io.EOF {
- return out, metadata, nil
- }
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
+ if _, err = io.Copy(io.Discard, response.Body); err != nil {
return out, metadata, &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
- }
- }
-
- decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUnlockSnapshotOutput(&output, decoder)
- if err != nil {
- var snapshot bytes.Buffer
- io.Copy(&snapshot, ringBuffer)
- err = &smithy.DeserializationError{
- Err: fmt.Errorf("failed to decode response body, %w", err),
- Snapshot: snapshot.Bytes(),
+ Err: fmt.Errorf("failed to discard response body, %w", err),
}
- return out, metadata, err
}
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUnlockSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUnassignPrivateIpAddresses(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71765,14 +72525,14 @@ func awsEc2query_deserializeOpErrorUnlockSnapshot(response *smithyhttp.Response,
}
}
-type awsEc2query_deserializeOpUnmonitorInstances struct {
+type awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress struct {
}
-func (*awsEc2query_deserializeOpUnmonitorInstances) ID() string {
+func (*awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUnmonitorInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUnassignPrivateNatGatewayAddress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71790,9 +72550,9 @@ func (m *awsEc2query_deserializeOpUnmonitorInstances) HandleDeserialize(ctx cont
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUnmonitorInstances(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUnassignPrivateNatGatewayAddress(response, &metadata)
}
- output := &UnmonitorInstancesOutput{}
+ output := &UnassignPrivateNatGatewayAddressOutput{}
out.Result = output
var buff [1024]byte
@@ -71813,7 +72573,7 @@ func (m *awsEc2query_deserializeOpUnmonitorInstances) HandleDeserialize(ctx cont
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUnmonitorInstancesOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUnassignPrivateNatGatewayAddressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71827,7 +72587,7 @@ func (m *awsEc2query_deserializeOpUnmonitorInstances) HandleDeserialize(ctx cont
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUnmonitorInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUnassignPrivateNatGatewayAddress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71860,14 +72620,14 @@ func awsEc2query_deserializeOpErrorUnmonitorInstances(response *smithyhttp.Respo
}
}
-type awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys struct {
+type awsEc2query_deserializeOpUnlockSnapshot struct {
}
-func (*awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) ID() string {
+func (*awsEc2query_deserializeOpUnlockSnapshot) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUnlockSnapshot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71885,9 +72645,9 @@ func (m *awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) HandleD
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUpdateCapacityManagerMonitoredTagKeys(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUnlockSnapshot(response, &metadata)
}
- output := &UpdateCapacityManagerMonitoredTagKeysOutput{}
+ output := &UnlockSnapshotOutput{}
out.Result = output
var buff [1024]byte
@@ -71908,7 +72668,7 @@ func (m *awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) HandleD
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUpdateCapacityManagerMonitoredTagKeysOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUnlockSnapshotOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -71922,7 +72682,7 @@ func (m *awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) HandleD
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUpdateCapacityManagerMonitoredTagKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUnlockSnapshot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -71955,14 +72715,14 @@ func awsEc2query_deserializeOpErrorUpdateCapacityManagerMonitoredTagKeys(respons
}
}
-type awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess struct {
+type awsEc2query_deserializeOpUnmonitorInstances struct {
}
-func (*awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) ID() string {
+func (*awsEc2query_deserializeOpUnmonitorInstances) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUnmonitorInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -71980,9 +72740,9 @@ func (m *awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) Hand
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUpdateCapacityManagerOrganizationsAccess(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUnmonitorInstances(response, &metadata)
}
- output := &UpdateCapacityManagerOrganizationsAccessOutput{}
+ output := &UnmonitorInstancesOutput{}
out.Result = output
var buff [1024]byte
@@ -72003,7 +72763,7 @@ func (m *awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) Hand
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUpdateCapacityManagerOrganizationsAccessOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUnmonitorInstancesOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -72017,7 +72777,7 @@ func (m *awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) Hand
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUpdateCapacityManagerOrganizationsAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUnmonitorInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -72050,14 +72810,14 @@ func awsEc2query_deserializeOpErrorUpdateCapacityManagerOrganizationsAccess(resp
}
}
-type awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocation struct {
+type awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys struct {
}
-func (*awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocation) ID() string {
+func (*awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUpdateCapacityManagerMonitoredTagKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -72075,9 +72835,9 @@ func (m *awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocati
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUpdateInterruptibleCapacityReservationAllocation(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUpdateCapacityManagerMonitoredTagKeys(response, &metadata)
}
- output := &UpdateInterruptibleCapacityReservationAllocationOutput{}
+ output := &UpdateCapacityManagerMonitoredTagKeysOutput{}
out.Result = output
var buff [1024]byte
@@ -72098,7 +72858,7 @@ func (m *awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocati
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUpdateInterruptibleCapacityReservationAllocationOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUpdateCapacityManagerMonitoredTagKeysOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -72112,7 +72872,7 @@ func (m *awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocati
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUpdateInterruptibleCapacityReservationAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUpdateCapacityManagerMonitoredTagKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -72145,14 +72905,14 @@ func awsEc2query_deserializeOpErrorUpdateInterruptibleCapacityReservationAllocat
}
}
-type awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress struct {
+type awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess struct {
}
-func (*awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) ID() string {
+func (*awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUpdateCapacityManagerOrganizationsAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -72170,9 +72930,9 @@ func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) Han
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsEgress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUpdateCapacityManagerOrganizationsAccess(response, &metadata)
}
- output := &UpdateSecurityGroupRuleDescriptionsEgressOutput{}
+ output := &UpdateCapacityManagerOrganizationsAccessOutput{}
out.Result = output
var buff [1024]byte
@@ -72193,7 +72953,7 @@ func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) Han
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUpdateSecurityGroupRuleDescriptionsEgressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUpdateCapacityManagerOrganizationsAccessOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -72207,7 +72967,7 @@ func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) Han
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUpdateCapacityManagerOrganizationsAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -72240,14 +73000,14 @@ func awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsEgress(res
}
}
-type awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress struct {
+type awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocation struct {
}
-func (*awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) ID() string {
+func (*awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocation) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUpdateInterruptibleCapacityReservationAllocation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -72265,9 +73025,9 @@ func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) Ha
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsIngress(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUpdateInterruptibleCapacityReservationAllocation(response, &metadata)
}
- output := &UpdateSecurityGroupRuleDescriptionsIngressOutput{}
+ output := &UpdateInterruptibleCapacityReservationAllocationOutput{}
out.Result = output
var buff [1024]byte
@@ -72288,7 +73048,7 @@ func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) Ha
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentUpdateSecurityGroupRuleDescriptionsIngressOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUpdateInterruptibleCapacityReservationAllocationOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -72302,7 +73062,7 @@ func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) Ha
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUpdateInterruptibleCapacityReservationAllocation(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -72335,14 +73095,14 @@ func awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsIngress(re
}
}
-type awsEc2query_deserializeOpWithdrawByoipCidr struct {
+type awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress struct {
}
-func (*awsEc2query_deserializeOpWithdrawByoipCidr) ID() string {
+func (*awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) ID() string {
return "OperationDeserializer"
}
-func (m *awsEc2query_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsEgress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
) {
out, metadata, err = next.HandleDeserialize(ctx, in)
@@ -72360,9 +73120,9 @@ func (m *awsEc2query_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx conte
}
if response.StatusCode < 200 || response.StatusCode >= 300 {
- return out, metadata, awsEc2query_deserializeOpErrorWithdrawByoipCidr(response, &metadata)
+ return out, metadata, awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsEgress(response, &metadata)
}
- output := &WithdrawByoipCidrOutput{}
+ output := &UpdateSecurityGroupRuleDescriptionsEgressOutput{}
out.Result = output
var buff [1024]byte
@@ -72383,7 +73143,7 @@ func (m *awsEc2query_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx conte
}
decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
- err = awsEc2query_deserializeOpDocumentWithdrawByoipCidrOutput(&output, decoder)
+ err = awsEc2query_deserializeOpDocumentUpdateSecurityGroupRuleDescriptionsEgressOutput(&output, decoder)
if err != nil {
var snapshot bytes.Buffer
io.Copy(&snapshot, ringBuffer)
@@ -72397,7 +73157,197 @@ func (m *awsEc2query_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx conte
return out, metadata, err
}
-func awsEc2query_deserializeOpErrorWithdrawByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+func awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsEgress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress struct {
+}
+
+func (*awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpUpdateSecurityGroupRuleDescriptionsIngress) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsIngress(response, &metadata)
+ }
+ output := &UpdateSecurityGroupRuleDescriptionsIngressOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentUpdateSecurityGroupRuleDescriptionsIngressOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorUpdateSecurityGroupRuleDescriptionsIngress(response *smithyhttp.Response, metadata *middleware.Metadata) error {
+ var errorBuffer bytes.Buffer
+ if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
+ return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
+ }
+ errorBody := bytes.NewReader(errorBuffer.Bytes())
+
+ errorCode := "UnknownError"
+ errorMessage := errorCode
+
+ errorComponents, err := ec2query.GetErrorResponseComponents(errorBody)
+ if err != nil {
+ return err
+ }
+ awsmiddleware.SetRequestIDMetadata(metadata, errorComponents.RequestID)
+ if len(errorComponents.Code) != 0 {
+ errorCode = errorComponents.Code
+ }
+ if len(errorComponents.Message) != 0 {
+ errorMessage = errorComponents.Message
+ }
+ errorBody.Seek(0, io.SeekStart)
+ switch {
+ default:
+ genericError := &smithy.GenericAPIError{
+ Code: errorCode,
+ Message: errorMessage,
+ }
+ return genericError
+
+ }
+}
+
+type awsEc2query_deserializeOpWithdrawByoipCidr struct {
+}
+
+func (*awsEc2query_deserializeOpWithdrawByoipCidr) ID() string {
+ return "OperationDeserializer"
+}
+
+func (m *awsEc2query_deserializeOpWithdrawByoipCidr) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
+ out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
+) {
+ out, metadata, err = next.HandleDeserialize(ctx, in)
+ if err != nil {
+ return out, metadata, err
+ }
+
+ _, span := tracing.StartSpan(ctx, "OperationDeserializer")
+ endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
+ defer endTimer()
+ defer span.End()
+ response, ok := out.RawResponse.(*smithyhttp.Response)
+ if !ok {
+ return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
+ }
+
+ if response.StatusCode < 200 || response.StatusCode >= 300 {
+ return out, metadata, awsEc2query_deserializeOpErrorWithdrawByoipCidr(response, &metadata)
+ }
+ output := &WithdrawByoipCidrOutput{}
+ out.Result = output
+
+ var buff [1024]byte
+ ringBuffer := smithyio.NewRingBuffer(buff[:])
+ body := io.TeeReader(response.Body, ringBuffer)
+ rootDecoder := xml.NewDecoder(body)
+ t, err := smithyxml.FetchRootElement(rootDecoder)
+ if err == io.EOF {
+ return out, metadata, nil
+ }
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ return out, metadata, &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ }
+
+ decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
+ err = awsEc2query_deserializeOpDocumentWithdrawByoipCidrOutput(&output, decoder)
+ if err != nil {
+ var snapshot bytes.Buffer
+ io.Copy(&snapshot, ringBuffer)
+ err = &smithy.DeserializationError{
+ Err: fmt.Errorf("failed to decode response body, %w", err),
+ Snapshot: snapshot.Bytes(),
+ }
+ return out, metadata, err
+ }
+
+ return out, metadata, err
+}
+
+func awsEc2query_deserializeOpErrorWithdrawByoipCidr(response *smithyhttp.Response, metadata *middleware.Metadata) error {
var errorBuffer bytes.Buffer
if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
@@ -76037,6 +76987,1055 @@ func awsEc2query_deserializeDocumentAnalysisSecurityGroupRule(v **types.Analysis
return nil
}
+func awsEc2query_deserializeDocumentApplicationStatus(v **types.ApplicationStatus, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatus
+ if *v == nil {
+ sv = &types.ApplicationStatus{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("detailSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatusDetailSet(&sv.Details, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("resumeAt", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.ResumeAt = ptr.Time(t)
+ }
+
+ case strings.EqualFold("status", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Status = types.ApplicationStatusEnum(xtv)
+ }
+
+ case strings.EqualFold("statusSince", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.StatusSince = ptr.Time(t)
+ }
+
+ case strings.EqualFold("statusTimeStamp", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.StatusTimeStamp = ptr.Time(t)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusCheckAssociationObject(v **types.ApplicationStatusCheckAssociationObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatusCheckAssociationObject
+ if *v == nil {
+ sv = &types.ApplicationStatusCheckAssociationObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatusCheckId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.ApplicationStatusCheckId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("associationType", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AssociationType = types.AssociationTypeEnum(xtv)
+ }
+
+ case strings.EqualFold("key", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Key = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("value", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Value = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusCheckAssociationSet(v *[]types.ApplicationStatusCheckAssociationObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.ApplicationStatusCheckAssociationObject
+ if *v == nil {
+ sv = make([]types.ApplicationStatusCheckAssociationObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.ApplicationStatusCheckAssociationObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckAssociationObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusCheckAssociationSetUnwrapped(v *[]types.ApplicationStatusCheckAssociationObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.ApplicationStatusCheckAssociationObject
+ if *v == nil {
+ sv = make([]types.ApplicationStatusCheckAssociationObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.ApplicationStatusCheckAssociationObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckAssociationObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentApplicationStatusCheckResponseObject(v **types.ApplicationStatusCheckResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatusCheckResponseObject
+ if *v == nil {
+ sv = &types.ApplicationStatusCheckResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("aggregation", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Aggregation = types.AggregationStatusEnum(xtv)
+ }
+
+ case strings.EqualFold("applicationStatusCheckId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.ApplicationStatusCheckId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("creationTime", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.CreationTime = ptr.Time(t)
+ }
+
+ case strings.EqualFold("deletionTime", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.DeletionTime = ptr.Time(t)
+ }
+
+ case strings.EqualFold("deviceIndex", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.DeviceIndex = ptr.Int32(int32(i64))
+ }
+
+ case strings.EqualFold("failureThreshold", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.FailureThreshold = ptr.Int32(int32(i64))
+ }
+
+ case strings.EqualFold("healthCheckPathSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentHealthCheckPathResponseList(&sv.HealthCheckPaths, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("initializationGracePeriodSeconds", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.InitializationGracePeriodSeconds = ptr.Int32(int32(i64))
+ }
+
+ case strings.EqualFold("interval", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.Interval = ptr.Int32(int32(i64))
+ }
+
+ case strings.EqualFold("ipScope", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.IpScope = types.IpScopeEnum(xtv)
+ }
+
+ case strings.EqualFold("ipVersion", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.IpVersion = types.IpVersionEnum(xtv)
+ }
+
+ case strings.EqualFold("lastUpdatedAt", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.LastUpdatedAt = ptr.Time(t)
+ }
+
+ case strings.EqualFold("modifyTime", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.ModifyTime = ptr.Time(t)
+ }
+
+ case strings.EqualFold("path", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Path = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("port", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.Port = ptr.Int32(int32(i64))
+ }
+
+ case strings.EqualFold("protocol", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Protocol = types.NetworkProtocolEnum(xtv)
+ }
+
+ case strings.EqualFold("statusCodeMatcher", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.StatusCodeMatcher = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("successThreshold", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.SuccessThreshold = ptr.Int32(int32(i64))
+ }
+
+ case strings.EqualFold("tagSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("targetTagAssociationSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentCustomKeyValuePairResponseSet(&sv.TargetTagAssociations, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("timeout", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.Timeout = ptr.Int32(int32(i64))
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusCheckResponseSet(v *[]types.ApplicationStatusCheckResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.ApplicationStatusCheckResponseObject
+ if *v == nil {
+ sv = make([]types.ApplicationStatusCheckResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.ApplicationStatusCheckResponseObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusCheckResponseSetUnwrapped(v *[]types.ApplicationStatusCheckResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.ApplicationStatusCheckResponseObject
+ if *v == nil {
+ sv = make([]types.ApplicationStatusCheckResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.ApplicationStatusCheckResponseObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentApplicationStatusDetail(v **types.ApplicationStatusDetail, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatusDetail
+ if *v == nil {
+ sv = &types.ApplicationStatusDetail{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("aggregation", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Aggregation = types.AggregationStatusEnum(xtv)
+ }
+
+ case strings.EqualFold("applicationStatusCheckId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.ApplicationStatusCheckId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("checkUpdateTime", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.CheckUpdateTime = ptr.Time(t)
+ }
+
+ case strings.EqualFold("reason", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatusReason(&sv.Reason, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("status", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Status = types.ApplicationStatusCheckEnum(xtv)
+ }
+
+ case strings.EqualFold("statusSince", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.StatusSince = ptr.Time(t)
+ }
+
+ case strings.EqualFold("statusTimeStamp", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.StatusTimeStamp = ptr.Time(t)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusDetailSet(v *[]types.ApplicationStatusDetail, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.ApplicationStatusDetail
+ if *v == nil {
+ sv = make([]types.ApplicationStatusDetail, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.ApplicationStatusDetail
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentApplicationStatusDetail(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusDetailSetUnwrapped(v *[]types.ApplicationStatusDetail, decoder smithyxml.NodeDecoder) error {
+ var sv []types.ApplicationStatusDetail
+ if *v == nil {
+ sv = make([]types.ApplicationStatusDetail, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.ApplicationStatusDetail
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentApplicationStatusDetail(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentApplicationStatusesResponseType(v **types.ApplicationStatusesResponseType, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatusesResponseType
+ if *v == nil {
+ sv = &types.ApplicationStatusesResponseType{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("instanceSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentInstanceApplicationStatusSet(&sv.Instances, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusReason(v **types.ApplicationStatusReason, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatusReason
+ if *v == nil {
+ sv = &types.ApplicationStatusReason{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("code", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Code = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("protocol", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Protocol = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("statusCode", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ i64, err := strconv.ParseInt(xtv, 10, 64)
+ if err != nil {
+ return err
+ }
+ sv.StatusCode = ptr.Int32(int32(i64))
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentApplicationStatusSummary(v **types.ApplicationStatusSummary, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.ApplicationStatusSummary
+ if *v == nil {
+ sv = &types.ApplicationStatusSummary{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("impairedSince", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.ImpairedSince = ptr.Time(t)
+ }
+
+ case strings.EqualFold("status", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Status = types.SummaryStatus(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeDocumentArchitectureTypeList(v *[]types.ArchitectureType, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -89764,6 +91763,136 @@ func awsEc2query_deserializeDocumentCustomerGatewayListUnwrapped(v *[]types.Cust
*v = sv
return nil
}
+func awsEc2query_deserializeDocumentCustomKeyValuePairResponseSet(v *[]types.CustomTagKeyValueResponsePair, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.CustomTagKeyValueResponsePair
+ if *v == nil {
+ sv = make([]types.CustomTagKeyValueResponsePair, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.CustomTagKeyValueResponsePair
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentCustomTagKeyValueResponsePair(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentCustomKeyValuePairResponseSetUnwrapped(v *[]types.CustomTagKeyValueResponsePair, decoder smithyxml.NodeDecoder) error {
+ var sv []types.CustomTagKeyValueResponsePair
+ if *v == nil {
+ sv = make([]types.CustomTagKeyValueResponsePair, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.CustomTagKeyValueResponsePair
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentCustomTagKeyValueResponsePair(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentCustomTagKeyValueResponsePair(v **types.CustomTagKeyValueResponsePair, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.CustomTagKeyValueResponsePair
+ if *v == nil {
+ sv = &types.CustomTagKeyValueResponsePair{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("key", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Key = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("value", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Value = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeDocumentDataResponse(v **types.DataResponse, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -101849,6 +103978,314 @@ func awsEc2query_deserializeDocumentGroupIdStringListUnwrapped(v *[]string, deco
*v = sv
return nil
}
+func awsEc2query_deserializeDocumentHealthCheckPathDestinationResponseList(v *[]types.HealthCheckPathDestinationResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.HealthCheckPathDestinationResponseObject
+ if *v == nil {
+ sv = make([]types.HealthCheckPathDestinationResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.HealthCheckPathDestinationResponseObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentHealthCheckPathDestinationResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentHealthCheckPathDestinationResponseListUnwrapped(v *[]types.HealthCheckPathDestinationResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.HealthCheckPathDestinationResponseObject
+ if *v == nil {
+ sv = make([]types.HealthCheckPathDestinationResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.HealthCheckPathDestinationResponseObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentHealthCheckPathDestinationResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentHealthCheckPathDestinationResponseObject(v **types.HealthCheckPathDestinationResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.HealthCheckPathDestinationResponseObject
+ if *v == nil {
+ sv = &types.HealthCheckPathDestinationResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("securityGroupId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.SecurityGroupId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("subnetId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.SubnetId = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentHealthCheckPathResponseList(v *[]types.HealthCheckPathResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.HealthCheckPathResponseObject
+ if *v == nil {
+ sv = make([]types.HealthCheckPathResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.HealthCheckPathResponseObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentHealthCheckPathResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentHealthCheckPathResponseListUnwrapped(v *[]types.HealthCheckPathResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.HealthCheckPathResponseObject
+ if *v == nil {
+ sv = make([]types.HealthCheckPathResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.HealthCheckPathResponseObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentHealthCheckPathResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentHealthCheckPathResponseObject(v **types.HealthCheckPathResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.HealthCheckPathResponseObject
+ if *v == nil {
+ sv = &types.HealthCheckPathResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("destinationSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentHealthCheckPathDestinationResponseList(&sv.Destinations, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("source", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentHealthCheckPathSourceResponseObject(&sv.Source, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentHealthCheckPathSourceResponseObject(v **types.HealthCheckPathSourceResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.HealthCheckPathSourceResponseObject
+ if *v == nil {
+ sv = &types.HealthCheckPathSourceResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("securityGroupId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.SecurityGroupId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("subnetId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.SubnetId = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeDocumentHibernationOptions(v **types.HibernationOptions, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -108630,6 +111067,161 @@ func awsEc2query_deserializeDocumentInstance(v **types.Instance, decoder smithyx
return nil
}
+func awsEc2query_deserializeDocumentInstanceApplicationStatus(v **types.InstanceApplicationStatus, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.InstanceApplicationStatus
+ if *v == nil {
+ sv = &types.InstanceApplicationStatus{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatus", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatus(&sv.ApplicationStatus, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("availabilityZone", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AvailabilityZone = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("availabilityZoneId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AvailabilityZoneId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("instanceId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.InstanceId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("tagSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentInstanceApplicationStatusSet(v *[]types.InstanceApplicationStatus, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.InstanceApplicationStatus
+ if *v == nil {
+ sv = make([]types.InstanceApplicationStatus, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.InstanceApplicationStatus
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentInstanceApplicationStatus(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentInstanceApplicationStatusSetUnwrapped(v *[]types.InstanceApplicationStatus, decoder smithyxml.NodeDecoder) error {
+ var sv []types.InstanceApplicationStatus
+ if *v == nil {
+ sv = make([]types.InstanceApplicationStatus, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.InstanceApplicationStatus
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentInstanceApplicationStatus(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
func awsEc2query_deserializeDocumentInstanceAttachmentEnaSrdSpecification(v **types.InstanceAttachmentEnaSrdSpecification, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -113537,6 +116129,12 @@ func awsEc2query_deserializeDocumentInstanceStatus(v **types.InstanceStatus, dec
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
+ case strings.EqualFold("applicationStatus", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatusSummary(&sv.ApplicationStatus, nodeDecoder); err != nil {
+ return err
+ }
+
case strings.EqualFold("attachedEbsStatus", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
if err := awsEc2query_deserializeDocumentEbsStatusSummary(&sv.AttachedEbsStatus, nodeDecoder); err != nil {
@@ -160065,6 +162663,149 @@ func awsEc2query_deserializeDocumentSubscriptionListUnwrapped(v *[]types.Subscri
*v = sv
return nil
}
+func awsEc2query_deserializeDocumentSuccessfulAssociationResponseObject(v **types.SuccessfulAssociationResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.SuccessfulAssociationResponseObject
+ if *v == nil {
+ sv = &types.SuccessfulAssociationResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatusCheckId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.ApplicationStatusCheckId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("associationType", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AssociationType = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("associationValue", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AssociationValue = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentSuccessfulAssociationResponseSet(v *[]types.SuccessfulAssociationResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.SuccessfulAssociationResponseObject
+ if *v == nil {
+ sv = make([]types.SuccessfulAssociationResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.SuccessfulAssociationResponseObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentSuccessfulAssociationResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentSuccessfulAssociationResponseSetUnwrapped(v *[]types.SuccessfulAssociationResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.SuccessfulAssociationResponseObject
+ if *v == nil {
+ sv = make([]types.SuccessfulAssociationResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.SuccessfulAssociationResponseObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentSuccessfulAssociationResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
func awsEc2query_deserializeDocumentSuccessfulInstanceCreditSpecificationItem(v **types.SuccessfulInstanceCreditSpecificationItem, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -160299,6 +163040,157 @@ func awsEc2query_deserializeDocumentSuccessfulQueuedPurchaseDeletionSetUnwrapped
*v = sv
return nil
}
+func awsEc2query_deserializeDocumentSuccessfulSuppressionResponseObject(v **types.SuccessfulSuppressionResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.SuccessfulSuppressionResponseObject
+ if *v == nil {
+ sv = &types.SuccessfulSuppressionResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("instanceId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.InstanceId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("resumeAt", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.ResumeAt = ptr.Time(t)
+ }
+
+ case strings.EqualFold("suppressAt", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.SuppressAt = ptr.Time(t)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentSuccessfulSuppressionResponseSet(v *[]types.SuccessfulSuppressionResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.SuccessfulSuppressionResponseObject
+ if *v == nil {
+ sv = make([]types.SuccessfulSuppressionResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.SuccessfulSuppressionResponseObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentSuccessfulSuppressionResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentSuccessfulSuppressionResponseSetUnwrapped(v *[]types.SuccessfulSuppressionResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.SuccessfulSuppressionResponseObject
+ if *v == nil {
+ sv = make([]types.SuccessfulSuppressionResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.SuccessfulSuppressionResponseObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentSuccessfulSuppressionResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
func awsEc2query_deserializeDocumentSupportedAdditionalProcessorFeatureList(v *[]types.SupportedAdditionalProcessorFeature, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -169941,6 +172833,162 @@ func awsEc2query_deserializeDocumentTunnelOptionsListUnwrapped(v *[]types.Tunnel
*v = sv
return nil
}
+func awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseObject(v **types.UnsuccessfulAssociationResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.UnsuccessfulAssociationResponseObject
+ if *v == nil {
+ sv = &types.UnsuccessfulAssociationResponseObject{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatusCheckId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.ApplicationStatusCheckId = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("associationType", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AssociationType = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("associationValue", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.AssociationValue = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("reason", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Reason = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseSet(v *[]types.UnsuccessfulAssociationResponseObject, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.UnsuccessfulAssociationResponseObject
+ if *v == nil {
+ sv = make([]types.UnsuccessfulAssociationResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.UnsuccessfulAssociationResponseObject
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseSetUnwrapped(v *[]types.UnsuccessfulAssociationResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.UnsuccessfulAssociationResponseObject
+ if *v == nil {
+ sv = make([]types.UnsuccessfulAssociationResponseObject, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.UnsuccessfulAssociationResponseObject
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseObject(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationItem(v **types.UnsuccessfulInstanceCreditSpecificationItem, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -170058,13 +173106,198 @@ func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationItemE
return nil
}
-func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSet(v *[]types.UnsuccessfulInstanceCreditSpecificationItem, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSet(v *[]types.UnsuccessfulInstanceCreditSpecificationItem, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv []types.UnsuccessfulInstanceCreditSpecificationItem
+ if *v == nil {
+ sv = make([]types.UnsuccessfulInstanceCreditSpecificationItem, 0)
+ } else {
+ sv = *v
+ }
+
+ originalDecoder := decoder
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ switch {
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.UnsuccessfulInstanceCreditSpecificationItem
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationItem(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ col = *destAddr
+ sv = append(sv, col)
+
+ default:
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSetUnwrapped(v *[]types.UnsuccessfulInstanceCreditSpecificationItem, decoder smithyxml.NodeDecoder) error {
+ var sv []types.UnsuccessfulInstanceCreditSpecificationItem
+ if *v == nil {
+ sv = make([]types.UnsuccessfulInstanceCreditSpecificationItem, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.UnsuccessfulInstanceCreditSpecificationItem
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationItem(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentUnsuccessfulItem(v **types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.UnsuccessfulItem
+ if *v == nil {
+ sv = &types.UnsuccessfulItem{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("error", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentUnsuccessfulItemError(&sv.Error, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("resourceId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.ResourceId = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentUnsuccessfulItemError(v **types.UnsuccessfulItemError, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *types.UnsuccessfulItemError
+ if *v == nil {
+ sv = &types.UnsuccessfulItemError{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("code", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Code = ptr.String(xtv)
+ }
+
+ case strings.EqualFold("message", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.Message = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeDocumentUnsuccessfulItemList(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv []types.UnsuccessfulInstanceCreditSpecificationItem
+ var sv []types.UnsuccessfulItem
if *v == nil {
- sv = make([]types.UnsuccessfulInstanceCreditSpecificationItem, 0)
+ sv = make([]types.UnsuccessfulItem, 0)
} else {
sv = *v
}
@@ -170080,10 +173313,10 @@ func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSet(v
}
switch {
case strings.EqualFold("item", t.Name.Local):
- var col types.UnsuccessfulInstanceCreditSpecificationItem
+ var col types.UnsuccessfulItem
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
destAddr := &col
- if err := awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationItem(&destAddr, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
return err
}
col = *destAddr
@@ -170102,22 +173335,22 @@ func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSet(v
return nil
}
-func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSetUnwrapped(v *[]types.UnsuccessfulInstanceCreditSpecificationItem, decoder smithyxml.NodeDecoder) error {
- var sv []types.UnsuccessfulInstanceCreditSpecificationItem
+func awsEc2query_deserializeDocumentUnsuccessfulItemListUnwrapped(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
+ var sv []types.UnsuccessfulItem
if *v == nil {
- sv = make([]types.UnsuccessfulInstanceCreditSpecificationItem, 0)
+ sv = make([]types.UnsuccessfulItem, 0)
} else {
sv = *v
}
switch {
default:
- var mv types.UnsuccessfulInstanceCreditSpecificationItem
+ var mv types.UnsuccessfulItem
t := decoder.StartEl
_ = t
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
destAddr := &mv
- if err := awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationItem(&destAddr, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
return err
}
mv = *destAddr
@@ -170126,17 +173359,18 @@ func awsEc2query_deserializeDocumentUnsuccessfulInstanceCreditSpecificationSetUn
*v = sv
return nil
}
-func awsEc2query_deserializeDocumentUnsuccessfulItem(v **types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeDocumentUnsuccessfulItemSet(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *types.UnsuccessfulItem
+ var sv []types.UnsuccessfulItem
if *v == nil {
- sv = &types.UnsuccessfulItem{}
+ sv = make([]types.UnsuccessfulItem, 0)
} else {
sv = *v
}
+ originalDecoder := decoder
for {
t, done, err := decoder.Token()
if err != nil {
@@ -170145,30 +173379,18 @@ func awsEc2query_deserializeDocumentUnsuccessfulItem(v **types.UnsuccessfulItem,
if done {
break
}
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("error", t.Name.Local):
+ case strings.EqualFold("item", t.Name.Local):
+ var col types.UnsuccessfulItem
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentUnsuccessfulItemError(&sv.Error, nodeDecoder); err != nil {
- return err
- }
-
- case strings.EqualFold("resourceId", t.Name.Local):
- val, err := decoder.Value()
- if err != nil {
+ destAddr := &col
+ if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
return err
}
- if val == nil {
- break
- }
- {
- xtv := string(val)
- sv.ResourceId = ptr.String(xtv)
- }
+ col = *destAddr
+ sv = append(sv, col)
default:
- // Do nothing and ignore the unexpected tag element
err = decoder.Decoder.Skip()
if err != nil {
return err
@@ -170181,13 +173403,37 @@ func awsEc2query_deserializeDocumentUnsuccessfulItem(v **types.UnsuccessfulItem,
return nil
}
-func awsEc2query_deserializeDocumentUnsuccessfulItemError(v **types.UnsuccessfulItemError, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeDocumentUnsuccessfulItemSetUnwrapped(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
+ var sv []types.UnsuccessfulItem
+ if *v == nil {
+ sv = make([]types.UnsuccessfulItem, 0)
+ } else {
+ sv = *v
+ }
+
+ switch {
+ default:
+ var mv types.UnsuccessfulItem
+ t := decoder.StartEl
+ _ = t
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ destAddr := &mv
+ if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
+ return err
+ }
+ mv = *destAddr
+ sv = append(sv, mv)
+ }
+ *v = sv
+ return nil
+}
+func awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseObject(v **types.UnsuccessfulSuppressionResponseObject, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *types.UnsuccessfulItemError
+ var sv *types.UnsuccessfulSuppressionResponseObject
if *v == nil {
- sv = &types.UnsuccessfulItemError{}
+ sv = &types.UnsuccessfulSuppressionResponseObject{}
} else {
sv = *v
}
@@ -170203,7 +173449,7 @@ func awsEc2query_deserializeDocumentUnsuccessfulItemError(v **types.Unsuccessful
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("code", t.Name.Local):
+ case strings.EqualFold("instanceId", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
@@ -170213,10 +173459,10 @@ func awsEc2query_deserializeDocumentUnsuccessfulItemError(v **types.Unsuccessful
}
{
xtv := string(val)
- sv.Code = ptr.String(xtv)
+ sv.InstanceId = ptr.String(xtv)
}
- case strings.EqualFold("message", t.Name.Local):
+ case strings.EqualFold("reason", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
@@ -170226,55 +173472,45 @@ func awsEc2query_deserializeDocumentUnsuccessfulItemError(v **types.Unsuccessful
}
{
xtv := string(val)
- sv.Message = ptr.String(xtv)
+ sv.Reason = ptr.String(xtv)
}
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
+ case strings.EqualFold("resumeAt", t.Name.Local):
+ val, err := decoder.Value()
if err != nil {
return err
}
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.ResumeAt = ptr.Time(t)
+ }
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeDocumentUnsuccessfulItemList(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv []types.UnsuccessfulItem
- if *v == nil {
- sv = make([]types.UnsuccessfulItem, 0)
- } else {
- sv = *v
- }
-
- originalDecoder := decoder
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- switch {
- case strings.EqualFold("item", t.Name.Local):
- var col types.UnsuccessfulItem
- nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- destAddr := &col
- if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
+ case strings.EqualFold("suppressAt", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
return err
}
- col = *destAddr
- sv = append(sv, col)
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ t, err := smithytime.ParseDateTime(xtv)
+ if err != nil {
+ return err
+ }
+ sv.SuppressAt = ptr.Time(t)
+ }
default:
+ // Do nothing and ignore the unexpected tag element
err = decoder.Decoder.Skip()
if err != nil {
return err
@@ -170287,37 +173523,13 @@ func awsEc2query_deserializeDocumentUnsuccessfulItemList(v *[]types.Unsuccessful
return nil
}
-func awsEc2query_deserializeDocumentUnsuccessfulItemListUnwrapped(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
- var sv []types.UnsuccessfulItem
- if *v == nil {
- sv = make([]types.UnsuccessfulItem, 0)
- } else {
- sv = *v
- }
-
- switch {
- default:
- var mv types.UnsuccessfulItem
- t := decoder.StartEl
- _ = t
- nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- destAddr := &mv
- if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
- return err
- }
- mv = *destAddr
- sv = append(sv, mv)
- }
- *v = sv
- return nil
-}
-func awsEc2query_deserializeDocumentUnsuccessfulItemSet(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseSet(v *[]types.UnsuccessfulSuppressionResponseObject, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv []types.UnsuccessfulItem
+ var sv []types.UnsuccessfulSuppressionResponseObject
if *v == nil {
- sv = make([]types.UnsuccessfulItem, 0)
+ sv = make([]types.UnsuccessfulSuppressionResponseObject, 0)
} else {
sv = *v
}
@@ -170333,10 +173545,10 @@ func awsEc2query_deserializeDocumentUnsuccessfulItemSet(v *[]types.UnsuccessfulI
}
switch {
case strings.EqualFold("item", t.Name.Local):
- var col types.UnsuccessfulItem
+ var col types.UnsuccessfulSuppressionResponseObject
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
destAddr := &col
- if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseObject(&destAddr, nodeDecoder); err != nil {
return err
}
col = *destAddr
@@ -170355,22 +173567,22 @@ func awsEc2query_deserializeDocumentUnsuccessfulItemSet(v *[]types.UnsuccessfulI
return nil
}
-func awsEc2query_deserializeDocumentUnsuccessfulItemSetUnwrapped(v *[]types.UnsuccessfulItem, decoder smithyxml.NodeDecoder) error {
- var sv []types.UnsuccessfulItem
+func awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseSetUnwrapped(v *[]types.UnsuccessfulSuppressionResponseObject, decoder smithyxml.NodeDecoder) error {
+ var sv []types.UnsuccessfulSuppressionResponseObject
if *v == nil {
- sv = make([]types.UnsuccessfulItem, 0)
+ sv = make([]types.UnsuccessfulSuppressionResponseObject, 0)
} else {
sv = *v
}
switch {
default:
- var mv types.UnsuccessfulItem
+ var mv types.UnsuccessfulSuppressionResponseObject
t := decoder.StartEl
_ = t
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
destAddr := &mv
- if err := awsEc2query_deserializeDocumentUnsuccessfulItem(&destAddr, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseObject(&destAddr, nodeDecoder); err != nil {
return err
}
mv = *destAddr
@@ -181794,6 +185006,54 @@ func awsEc2query_deserializeOpDocumentAssociateAddressOutput(v **AssociateAddres
return nil
}
+func awsEc2query_deserializeOpDocumentAssociateApplicationStatusCheckOutput(v **AssociateApplicationStatusCheckOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *AssociateApplicationStatusCheckOutput
+ if *v == nil {
+ sv = &AssociateApplicationStatusCheckOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("successfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentSuccessfulAssociationResponseSet(&sv.SuccessfulResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("unsuccessfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseSet(&sv.UnsuccessfulResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeOpDocumentAssociateCapacityReservationBillingOwnerOutput(v **AssociateCapacityReservationBillingOwnerOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -183976,6 +187236,48 @@ func awsEc2query_deserializeOpDocumentCopyVolumesOutput(v **CopyVolumesOutput, d
return nil
}
+func awsEc2query_deserializeOpDocumentCreateApplicationStatusCheckOutput(v **CreateApplicationStatusCheckOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *CreateApplicationStatusCheckOutput
+ if *v == nil {
+ sv = &CreateApplicationStatusCheckOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatusCheck", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckResponseObject(&sv.ApplicationStatusCheck, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeOpDocumentCreateCapacityManagerDataExportOutput(v **CreateCapacityManagerDataExportOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -189529,6 +192831,48 @@ func awsEc2query_deserializeOpDocumentCreateVpnGatewayOutput(v **CreateVpnGatewa
return nil
}
+func awsEc2query_deserializeOpDocumentDeleteApplicationStatusCheckOutput(v **DeleteApplicationStatusCheckOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DeleteApplicationStatusCheckOutput
+ if *v == nil {
+ sv = &DeleteApplicationStatusCheckOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatusCheck", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckResponseObject(&sv.ApplicationStatusCheck, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeOpDocumentDeleteCapacityManagerDataExportOutput(v **DeleteCapacityManagerDataExportOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -192951,13 +196295,252 @@ func awsEc2query_deserializeOpDocumentDeleteVpnConcentratorOutput(v **DeleteVpnC
return nil
}
-func awsEc2query_deserializeOpDocumentDeprovisionByoipCidrOutput(v **DeprovisionByoipCidrOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDeprovisionByoipCidrOutput(v **DeprovisionByoipCidrOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DeprovisionByoipCidrOutput
+ if *v == nil {
+ sv = &DeprovisionByoipCidrOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("byoipCidr", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentByoipCidr(&sv.ByoipCidr, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDeprovisionIpamByoasnOutput(v **DeprovisionIpamByoasnOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DeprovisionIpamByoasnOutput
+ if *v == nil {
+ sv = &DeprovisionIpamByoasnOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("byoasn", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentByoasn(&sv.Byoasn, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDeprovisionIpamPoolCidrOutput(v **DeprovisionIpamPoolCidrOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DeprovisionIpamPoolCidrOutput
+ if *v == nil {
+ sv = &DeprovisionIpamPoolCidrOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("ipamPoolCidr", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentIpamPoolCidr(&sv.IpamPoolCidr, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDeprovisionPublicIpv4PoolCidrOutput(v **DeprovisionPublicIpv4PoolCidrOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DeprovisionPublicIpv4PoolCidrOutput
+ if *v == nil {
+ sv = &DeprovisionPublicIpv4PoolCidrOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("deprovisionedAddressSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentDeprovisionedAddressSet(&sv.DeprovisionedAddresses, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("poolId", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.PoolId = ptr.String(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDeregisterImageOutput(v **DeregisterImageOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DeregisterImageOutput
+ if *v == nil {
+ sv = &DeregisterImageOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("deleteSnapshotResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentDeleteSnapshotResultSet(&sv.DeleteSnapshotResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("return", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv, err := strconv.ParseBool(string(val))
+ if err != nil {
+ return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
+ }
+ sv.Return = ptr.Bool(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDeregisterInstanceEventNotificationAttributesOutput(v **DeregisterInstanceEventNotificationAttributesOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeprovisionByoipCidrOutput
+ var sv *DeregisterInstanceEventNotificationAttributesOutput
if *v == nil {
- sv = &DeprovisionByoipCidrOutput{}
+ sv = &DeregisterInstanceEventNotificationAttributesOutput{}
} else {
sv = *v
}
@@ -192973,9 +196556,9 @@ func awsEc2query_deserializeOpDocumentDeprovisionByoipCidrOutput(v **Deprovision
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("byoipCidr", t.Name.Local):
+ case strings.EqualFold("instanceTagAttribute", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentByoipCidr(&sv.ByoipCidr, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentInstanceTagNotificationAttribute(&sv.InstanceTagAttribute, nodeDecoder); err != nil {
return err
}
@@ -192993,13 +196576,13 @@ func awsEc2query_deserializeOpDocumentDeprovisionByoipCidrOutput(v **Deprovision
return nil
}
-func awsEc2query_deserializeOpDocumentDeprovisionIpamByoasnOutput(v **DeprovisionIpamByoasnOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupMembersOutput(v **DeregisterTransitGatewayMulticastGroupMembersOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeprovisionIpamByoasnOutput
+ var sv *DeregisterTransitGatewayMulticastGroupMembersOutput
if *v == nil {
- sv = &DeprovisionIpamByoasnOutput{}
+ sv = &DeregisterTransitGatewayMulticastGroupMembersOutput{}
} else {
sv = *v
}
@@ -193015,9 +196598,9 @@ func awsEc2query_deserializeOpDocumentDeprovisionIpamByoasnOutput(v **Deprovisio
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("byoasn", t.Name.Local):
+ case strings.EqualFold("deregisteredMulticastGroupMembers", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentByoasn(&sv.Byoasn, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentTransitGatewayMulticastDeregisteredGroupMembers(&sv.DeregisteredMulticastGroupMembers, nodeDecoder); err != nil {
return err
}
@@ -193035,13 +196618,13 @@ func awsEc2query_deserializeOpDocumentDeprovisionIpamByoasnOutput(v **Deprovisio
return nil
}
-func awsEc2query_deserializeOpDocumentDeprovisionIpamPoolCidrOutput(v **DeprovisionIpamPoolCidrOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupSourcesOutput(v **DeregisterTransitGatewayMulticastGroupSourcesOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeprovisionIpamPoolCidrOutput
+ var sv *DeregisterTransitGatewayMulticastGroupSourcesOutput
if *v == nil {
- sv = &DeprovisionIpamPoolCidrOutput{}
+ sv = &DeregisterTransitGatewayMulticastGroupSourcesOutput{}
} else {
sv = *v
}
@@ -193057,9 +196640,9 @@ func awsEc2query_deserializeOpDocumentDeprovisionIpamPoolCidrOutput(v **Deprovis
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("ipamPoolCidr", t.Name.Local):
+ case strings.EqualFold("deregisteredMulticastGroupSources", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentIpamPoolCidr(&sv.IpamPoolCidr, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentTransitGatewayMulticastDeregisteredGroupSources(&sv.DeregisteredMulticastGroupSources, nodeDecoder); err != nil {
return err
}
@@ -193077,13 +196660,13 @@ func awsEc2query_deserializeOpDocumentDeprovisionIpamPoolCidrOutput(v **Deprovis
return nil
}
-func awsEc2query_deserializeOpDocumentDeprovisionPublicIpv4PoolCidrOutput(v **DeprovisionPublicIpv4PoolCidrOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeAccountAttributesOutput(v **DescribeAccountAttributesOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeprovisionPublicIpv4PoolCidrOutput
+ var sv *DescribeAccountAttributesOutput
if *v == nil {
- sv = &DeprovisionPublicIpv4PoolCidrOutput{}
+ sv = &DescribeAccountAttributesOutput{}
} else {
sv = *v
}
@@ -193099,24 +196682,11 @@ func awsEc2query_deserializeOpDocumentDeprovisionPublicIpv4PoolCidrOutput(v **De
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("deprovisionedAddressSet", t.Name.Local):
+ case strings.EqualFold("accountAttributeSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentDeprovisionedAddressSet(&sv.DeprovisionedAddresses, nodeDecoder); err != nil {
- return err
- }
-
- case strings.EqualFold("poolId", t.Name.Local):
- val, err := decoder.Value()
- if err != nil {
+ if err := awsEc2query_deserializeDocumentAccountAttributeList(&sv.AccountAttributes, nodeDecoder); err != nil {
return err
}
- if val == nil {
- break
- }
- {
- xtv := string(val)
- sv.PoolId = ptr.String(xtv)
- }
default:
// Do nothing and ignore the unexpected tag element
@@ -193132,13 +196702,13 @@ func awsEc2query_deserializeOpDocumentDeprovisionPublicIpv4PoolCidrOutput(v **De
return nil
}
-func awsEc2query_deserializeOpDocumentDeregisterImageOutput(v **DeregisterImageOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeAccountVpcEncryptionControlOutput(v **DescribeAccountVpcEncryptionControlOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeregisterImageOutput
+ var sv *DescribeAccountVpcEncryptionControlOutput
if *v == nil {
- sv = &DeregisterImageOutput{}
+ sv = &DescribeAccountVpcEncryptionControlOutput{}
} else {
sv = *v
}
@@ -193154,27 +196724,11 @@ func awsEc2query_deserializeOpDocumentDeregisterImageOutput(v **DeregisterImageO
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("deleteSnapshotResultSet", t.Name.Local):
+ case strings.EqualFold("accountVpcEncryptionControl", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentDeleteSnapshotResultSet(&sv.DeleteSnapshotResults, nodeDecoder); err != nil {
- return err
- }
-
- case strings.EqualFold("return", t.Name.Local):
- val, err := decoder.Value()
- if err != nil {
+ if err := awsEc2query_deserializeDocumentAccountVpcEncryptionControl(&sv.AccountVpcEncryptionControl, nodeDecoder); err != nil {
return err
}
- if val == nil {
- break
- }
- {
- xtv, err := strconv.ParseBool(string(val))
- if err != nil {
- return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
- }
- sv.Return = ptr.Bool(xtv)
- }
default:
// Do nothing and ignore the unexpected tag element
@@ -193190,13 +196744,13 @@ func awsEc2query_deserializeOpDocumentDeregisterImageOutput(v **DeregisterImageO
return nil
}
-func awsEc2query_deserializeOpDocumentDeregisterInstanceEventNotificationAttributesOutput(v **DeregisterInstanceEventNotificationAttributesOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeAddressesAttributeOutput(v **DescribeAddressesAttributeOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeregisterInstanceEventNotificationAttributesOutput
+ var sv *DescribeAddressesAttributeOutput
if *v == nil {
- sv = &DeregisterInstanceEventNotificationAttributesOutput{}
+ sv = &DescribeAddressesAttributeOutput{}
} else {
sv = *v
}
@@ -193212,52 +196766,23 @@ func awsEc2query_deserializeOpDocumentDeregisterInstanceEventNotificationAttribu
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("instanceTagAttribute", t.Name.Local):
+ case strings.EqualFold("addressSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentInstanceTagNotificationAttribute(&sv.InstanceTagAttribute, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentAddressSet(&sv.Addresses, nodeDecoder); err != nil {
return err
}
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
+ case strings.EqualFold("nextToken", t.Name.Local):
+ val, err := decoder.Value()
if err != nil {
return err
}
-
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupMembersOutput(v **DeregisterTransitGatewayMulticastGroupMembersOutput, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv *DeregisterTransitGatewayMulticastGroupMembersOutput
- if *v == nil {
- sv = &DeregisterTransitGatewayMulticastGroupMembersOutput{}
- } else {
- sv = *v
- }
-
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
- switch {
- case strings.EqualFold("deregisteredMulticastGroupMembers", t.Name.Local):
- nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentTransitGatewayMulticastDeregisteredGroupMembers(&sv.DeregisteredMulticastGroupMembers, nodeDecoder); err != nil {
- return err
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.NextToken = ptr.String(xtv)
}
default:
@@ -193274,13 +196799,13 @@ func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupMemb
return nil
}
-func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupSourcesOutput(v **DeregisterTransitGatewayMulticastGroupSourcesOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeAddressesOutput(v **DescribeAddressesOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DeregisterTransitGatewayMulticastGroupSourcesOutput
+ var sv *DescribeAddressesOutput
if *v == nil {
- sv = &DeregisterTransitGatewayMulticastGroupSourcesOutput{}
+ sv = &DescribeAddressesOutput{}
} else {
sv = *v
}
@@ -193296,9 +196821,9 @@ func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupSour
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("deregisteredMulticastGroupSources", t.Name.Local):
+ case strings.EqualFold("addressesSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentTransitGatewayMulticastDeregisteredGroupSources(&sv.DeregisteredMulticastGroupSources, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentAddressList(&sv.Addresses, nodeDecoder); err != nil {
return err
}
@@ -193316,13 +196841,13 @@ func awsEc2query_deserializeOpDocumentDeregisterTransitGatewayMulticastGroupSour
return nil
}
-func awsEc2query_deserializeOpDocumentDescribeAccountAttributesOutput(v **DescribeAccountAttributesOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeAddressTransfersOutput(v **DescribeAddressTransfersOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DescribeAccountAttributesOutput
+ var sv *DescribeAddressTransfersOutput
if *v == nil {
- sv = &DescribeAccountAttributesOutput{}
+ sv = &DescribeAddressTransfersOutput{}
} else {
sv = *v
}
@@ -193338,12 +196863,25 @@ func awsEc2query_deserializeOpDocumentDescribeAccountAttributesOutput(v **Descri
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("accountAttributeSet", t.Name.Local):
+ case strings.EqualFold("addressTransferSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentAccountAttributeList(&sv.AccountAttributes, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentAddressTransferList(&sv.AddressTransfers, nodeDecoder); err != nil {
return err
}
+ case strings.EqualFold("nextToken", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.NextToken = ptr.String(xtv)
+ }
+
default:
// Do nothing and ignore the unexpected tag element
err = decoder.Decoder.Skip()
@@ -193358,13 +196896,13 @@ func awsEc2query_deserializeOpDocumentDescribeAccountAttributesOutput(v **Descri
return nil
}
-func awsEc2query_deserializeOpDocumentDescribeAccountVpcEncryptionControlOutput(v **DescribeAccountVpcEncryptionControlOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeAggregateIdFormatOutput(v **DescribeAggregateIdFormatOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DescribeAccountVpcEncryptionControlOutput
+ var sv *DescribeAggregateIdFormatOutput
if *v == nil {
- sv = &DescribeAccountVpcEncryptionControlOutput{}
+ sv = &DescribeAggregateIdFormatOutput{}
} else {
sv = *v
}
@@ -193380,11 +196918,27 @@ func awsEc2query_deserializeOpDocumentDescribeAccountVpcEncryptionControlOutput(
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("accountVpcEncryptionControl", t.Name.Local):
+ case strings.EqualFold("statusSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentAccountVpcEncryptionControl(&sv.AccountVpcEncryptionControl, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentIdFormatList(&sv.Statuses, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("useLongIdsAggregated", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
return err
}
+ if val == nil {
+ break
+ }
+ {
+ xtv, err := strconv.ParseBool(string(val))
+ if err != nil {
+ return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
+ }
+ sv.UseLongIdsAggregated = ptr.Bool(xtv)
+ }
default:
// Do nothing and ignore the unexpected tag element
@@ -193400,13 +196954,13 @@ func awsEc2query_deserializeOpDocumentDescribeAccountVpcEncryptionControlOutput(
return nil
}
-func awsEc2query_deserializeOpDocumentDescribeAddressesAttributeOutput(v **DescribeAddressesAttributeOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeApplicationStatusCheckAssociationsOutput(v **DescribeApplicationStatusCheckAssociationsOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DescribeAddressesAttributeOutput
+ var sv *DescribeApplicationStatusCheckAssociationsOutput
if *v == nil {
- sv = &DescribeAddressesAttributeOutput{}
+ sv = &DescribeApplicationStatusCheckAssociationsOutput{}
} else {
sv = *v
}
@@ -193422,9 +196976,9 @@ func awsEc2query_deserializeOpDocumentDescribeAddressesAttributeOutput(v **Descr
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("addressSet", t.Name.Local):
+ case strings.EqualFold("associationSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentAddressSet(&sv.Addresses, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckAssociationSet(&sv.Associations, nodeDecoder); err != nil {
return err
}
@@ -193441,45 +196995,9 @@ func awsEc2query_deserializeOpDocumentDescribeAddressesAttributeOutput(v **Descr
sv.NextToken = ptr.String(xtv)
}
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
- if err != nil {
- return err
- }
-
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeOpDocumentDescribeAddressesOutput(v **DescribeAddressesOutput, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv *DescribeAddressesOutput
- if *v == nil {
- sv = &DescribeAddressesOutput{}
- } else {
- sv = *v
- }
-
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
- switch {
- case strings.EqualFold("addressesSet", t.Name.Local):
+ case strings.EqualFold("tagSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentAddressList(&sv.Addresses, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentTagList(&sv.Tags, nodeDecoder); err != nil {
return err
}
@@ -193497,13 +197015,13 @@ func awsEc2query_deserializeOpDocumentDescribeAddressesOutput(v **DescribeAddres
return nil
}
-func awsEc2query_deserializeOpDocumentDescribeAddressTransfersOutput(v **DescribeAddressTransfersOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeApplicationStatusChecksOutput(v **DescribeApplicationStatusChecksOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DescribeAddressTransfersOutput
+ var sv *DescribeApplicationStatusChecksOutput
if *v == nil {
- sv = &DescribeAddressTransfersOutput{}
+ sv = &DescribeApplicationStatusChecksOutput{}
} else {
sv = *v
}
@@ -193519,9 +197037,9 @@ func awsEc2query_deserializeOpDocumentDescribeAddressTransfersOutput(v **Describ
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("addressTransferSet", t.Name.Local):
+ case strings.EqualFold("applicationStatusCheckSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentAddressTransferList(&sv.AddressTransfers, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckResponseSet(&sv.ApplicationStatusChecks, nodeDecoder); err != nil {
return err
}
@@ -193552,13 +197070,13 @@ func awsEc2query_deserializeOpDocumentDescribeAddressTransfersOutput(v **Describ
return nil
}
-func awsEc2query_deserializeOpDocumentDescribeAggregateIdFormatOutput(v **DescribeAggregateIdFormatOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDescribeApplicationStatusOutput(v **DescribeApplicationStatusOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DescribeAggregateIdFormatOutput
+ var sv *DescribeApplicationStatusOutput
if *v == nil {
- sv = &DescribeAggregateIdFormatOutput{}
+ sv = &DescribeApplicationStatusOutput{}
} else {
sv = *v
}
@@ -193574,13 +197092,13 @@ func awsEc2query_deserializeOpDocumentDescribeAggregateIdFormatOutput(v **Descri
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("statusSet", t.Name.Local):
+ case strings.EqualFold("applicationStatusesResponseType", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentIdFormatList(&sv.Statuses, nodeDecoder); err != nil {
+ if err := awsEc2query_deserializeDocumentApplicationStatusesResponseType(&sv.ApplicationStatuses, nodeDecoder); err != nil {
return err
}
- case strings.EqualFold("useLongIdsAggregated", t.Name.Local):
+ case strings.EqualFold("nextToken", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
@@ -193589,11 +197107,8 @@ func awsEc2query_deserializeOpDocumentDescribeAggregateIdFormatOutput(v **Descri
break
}
{
- xtv, err := strconv.ParseBool(string(val))
- if err != nil {
- return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
- }
- sv.UseLongIdsAggregated = ptr.Bool(xtv)
+ xtv := string(val)
+ sv.NextToken = ptr.String(xtv)
}
default:
@@ -204130,6 +207645,54 @@ func awsEc2query_deserializeOpDocumentDisableAllowedImagesSettingsOutput(v **Dis
return nil
}
+func awsEc2query_deserializeOpDocumentDisableApplicationStatusCheckSuppressionOutput(v **DisableApplicationStatusCheckSuppressionOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DisableApplicationStatusCheckSuppressionOutput
+ if *v == nil {
+ sv = &DisableApplicationStatusCheckSuppressionOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("successfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentSuccessfulSuppressionResponseSet(&sv.SuccessfulResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("unsuccessfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseSet(&sv.UnsuccessfulResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionOutput(v **DisableAwsNetworkPerformanceMetricSubscriptionOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -204842,55 +208405,250 @@ func awsEc2query_deserializeOpDocumentDisableIpamPolicyOutput(v **DisableIpamPol
return nil
}
-func awsEc2query_deserializeOpDocumentDisableRouteServerPropagationOutput(v **DisableRouteServerPropagationOutput, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv *DisableRouteServerPropagationOutput
- if *v == nil {
- sv = &DisableRouteServerPropagationOutput{}
- } else {
- sv = *v
- }
-
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
- switch {
- case strings.EqualFold("routeServerPropagation", t.Name.Local):
- nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentRouteServerPropagation(&sv.RouteServerPropagation, nodeDecoder); err != nil {
- return err
- }
-
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
- if err != nil {
- return err
- }
-
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeOpDocumentDisableSerialConsoleAccessOutput(v **DisableSerialConsoleAccessOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDisableRouteServerPropagationOutput(v **DisableRouteServerPropagationOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DisableRouteServerPropagationOutput
+ if *v == nil {
+ sv = &DisableRouteServerPropagationOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("routeServerPropagation", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentRouteServerPropagation(&sv.RouteServerPropagation, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDisableSerialConsoleAccessOutput(v **DisableSerialConsoleAccessOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DisableSerialConsoleAccessOutput
+ if *v == nil {
+ sv = &DisableSerialConsoleAccessOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("serialConsoleAccessEnabled", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv, err := strconv.ParseBool(string(val))
+ if err != nil {
+ return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
+ }
+ sv.SerialConsoleAccessEnabled = ptr.Bool(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDisableSnapshotBlockPublicAccessOutput(v **DisableSnapshotBlockPublicAccessOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DisableSnapshotBlockPublicAccessOutput
+ if *v == nil {
+ sv = &DisableSnapshotBlockPublicAccessOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("state", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv := string(val)
+ sv.State = types.SnapshotBlockPublicAccessState(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDisableTransitGatewayRouteTablePropagationOutput(v **DisableTransitGatewayRouteTablePropagationOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DisableTransitGatewayRouteTablePropagationOutput
+ if *v == nil {
+ sv = &DisableTransitGatewayRouteTablePropagationOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("propagation", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentTransitGatewayPropagation(&sv.Propagation, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDisableVpcClassicLinkDnsSupportOutput(v **DisableVpcClassicLinkDnsSupportOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *DisableVpcClassicLinkDnsSupportOutput
+ if *v == nil {
+ sv = &DisableVpcClassicLinkDnsSupportOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("return", t.Name.Local):
+ val, err := decoder.Value()
+ if err != nil {
+ return err
+ }
+ if val == nil {
+ break
+ }
+ {
+ xtv, err := strconv.ParseBool(string(val))
+ if err != nil {
+ return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
+ }
+ sv.Return = ptr.Bool(xtv)
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
+func awsEc2query_deserializeOpDocumentDisableVpcClassicLinkOutput(v **DisableVpcClassicLinkOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DisableSerialConsoleAccessOutput
+ var sv *DisableVpcClassicLinkOutput
if *v == nil {
- sv = &DisableSerialConsoleAccessOutput{}
+ sv = &DisableVpcClassicLinkOutput{}
} else {
sv = *v
}
@@ -204906,7 +208664,7 @@ func awsEc2query_deserializeOpDocumentDisableSerialConsoleAccessOutput(v **Disab
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("serialConsoleAccessEnabled", t.Name.Local):
+ case strings.EqualFold("return", t.Name.Local):
val, err := decoder.Value()
if err != nil {
return err
@@ -204919,56 +208677,7 @@ func awsEc2query_deserializeOpDocumentDisableSerialConsoleAccessOutput(v **Disab
if err != nil {
return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
}
- sv.SerialConsoleAccessEnabled = ptr.Bool(xtv)
- }
-
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
- if err != nil {
- return err
- }
-
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeOpDocumentDisableSnapshotBlockPublicAccessOutput(v **DisableSnapshotBlockPublicAccessOutput, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv *DisableSnapshotBlockPublicAccessOutput
- if *v == nil {
- sv = &DisableSnapshotBlockPublicAccessOutput{}
- } else {
- sv = *v
- }
-
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
- switch {
- case strings.EqualFold("state", t.Name.Local):
- val, err := decoder.Value()
- if err != nil {
- return err
- }
- if val == nil {
- break
- }
- {
- xtv := string(val)
- sv.State = types.SnapshotBlockPublicAccessState(xtv)
+ sv.Return = ptr.Bool(xtv)
}
default:
@@ -204985,13 +208694,13 @@ func awsEc2query_deserializeOpDocumentDisableSnapshotBlockPublicAccessOutput(v *
return nil
}
-func awsEc2query_deserializeOpDocumentDisableTransitGatewayRouteTablePropagationOutput(v **DisableTransitGatewayRouteTablePropagationOutput, decoder smithyxml.NodeDecoder) error {
+func awsEc2query_deserializeOpDocumentDisassociateApplicationStatusCheckOutput(v **DisassociateApplicationStatusCheckOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
}
- var sv *DisableTransitGatewayRouteTablePropagationOutput
+ var sv *DisassociateApplicationStatusCheckOutput
if *v == nil {
- sv = &DisableTransitGatewayRouteTablePropagationOutput{}
+ sv = &DisassociateApplicationStatusCheckOutput{}
} else {
sv = *v
}
@@ -205007,115 +208716,17 @@ func awsEc2query_deserializeOpDocumentDisableTransitGatewayRouteTablePropagation
originalDecoder := decoder
decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
switch {
- case strings.EqualFold("propagation", t.Name.Local):
+ case strings.EqualFold("successfulResultSet", t.Name.Local):
nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
- if err := awsEc2query_deserializeDocumentTransitGatewayPropagation(&sv.Propagation, nodeDecoder); err != nil {
- return err
- }
-
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
- if err != nil {
- return err
- }
-
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeOpDocumentDisableVpcClassicLinkDnsSupportOutput(v **DisableVpcClassicLinkDnsSupportOutput, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv *DisableVpcClassicLinkDnsSupportOutput
- if *v == nil {
- sv = &DisableVpcClassicLinkDnsSupportOutput{}
- } else {
- sv = *v
- }
-
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
- switch {
- case strings.EqualFold("return", t.Name.Local):
- val, err := decoder.Value()
- if err != nil {
- return err
- }
- if val == nil {
- break
- }
- {
- xtv, err := strconv.ParseBool(string(val))
- if err != nil {
- return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
- }
- sv.Return = ptr.Bool(xtv)
- }
-
- default:
- // Do nothing and ignore the unexpected tag element
- err = decoder.Decoder.Skip()
- if err != nil {
+ if err := awsEc2query_deserializeDocumentSuccessfulAssociationResponseSet(&sv.SuccessfulResults, nodeDecoder); err != nil {
return err
}
- }
- decoder = originalDecoder
- }
- *v = sv
- return nil
-}
-
-func awsEc2query_deserializeOpDocumentDisableVpcClassicLinkOutput(v **DisableVpcClassicLinkOutput, decoder smithyxml.NodeDecoder) error {
- if v == nil {
- return fmt.Errorf("unexpected nil of type %T", v)
- }
- var sv *DisableVpcClassicLinkOutput
- if *v == nil {
- sv = &DisableVpcClassicLinkOutput{}
- } else {
- sv = *v
- }
-
- for {
- t, done, err := decoder.Token()
- if err != nil {
- return err
- }
- if done {
- break
- }
- originalDecoder := decoder
- decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
- switch {
- case strings.EqualFold("return", t.Name.Local):
- val, err := decoder.Value()
- if err != nil {
+ case strings.EqualFold("unsuccessfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentUnsuccessfulAssociationResponseSet(&sv.UnsuccessfulResults, nodeDecoder); err != nil {
return err
}
- if val == nil {
- break
- }
- {
- xtv, err := strconv.ParseBool(string(val))
- if err != nil {
- return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", val)
- }
- sv.Return = ptr.Bool(xtv)
- }
default:
// Do nothing and ignore the unexpected tag element
@@ -206002,6 +209613,54 @@ func awsEc2query_deserializeOpDocumentEnableAllowedImagesSettingsOutput(v **Enab
return nil
}
+func awsEc2query_deserializeOpDocumentEnableApplicationStatusCheckSuppressionOutput(v **EnableApplicationStatusCheckSuppressionOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *EnableApplicationStatusCheckSuppressionOutput
+ if *v == nil {
+ sv = &EnableApplicationStatusCheckSuppressionOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("successfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentSuccessfulSuppressionResponseSet(&sv.SuccessfulResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ case strings.EqualFold("unsuccessfulResultSet", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentUnsuccessfulSuppressionResponseSet(&sv.UnsuccessfulResults, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeOpDocumentEnableAwsNetworkPerformanceMetricSubscriptionOutput(v **EnableAwsNetworkPerformanceMetricSubscriptionOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
@@ -212808,6 +216467,48 @@ func awsEc2query_deserializeOpDocumentModifyAddressAttributeOutput(v **ModifyAdd
return nil
}
+func awsEc2query_deserializeOpDocumentModifyApplicationStatusCheckOutput(v **ModifyApplicationStatusCheckOutput, decoder smithyxml.NodeDecoder) error {
+ if v == nil {
+ return fmt.Errorf("unexpected nil of type %T", v)
+ }
+ var sv *ModifyApplicationStatusCheckOutput
+ if *v == nil {
+ sv = &ModifyApplicationStatusCheckOutput{}
+ } else {
+ sv = *v
+ }
+
+ for {
+ t, done, err := decoder.Token()
+ if err != nil {
+ return err
+ }
+ if done {
+ break
+ }
+ originalDecoder := decoder
+ decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
+ switch {
+ case strings.EqualFold("applicationStatusCheck", t.Name.Local):
+ nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
+ if err := awsEc2query_deserializeDocumentApplicationStatusCheckResponseObject(&sv.ApplicationStatusCheck, nodeDecoder); err != nil {
+ return err
+ }
+
+ default:
+ // Do nothing and ignore the unexpected tag element
+ err = decoder.Decoder.Skip()
+ if err != nil {
+ return err
+ }
+
+ }
+ decoder = originalDecoder
+ }
+ *v = sv
+ return nil
+}
+
func awsEc2query_deserializeOpDocumentModifyAvailabilityZoneGroupOutput(v **ModifyAvailabilityZoneGroupOutput, decoder smithyxml.NodeDecoder) error {
if v == nil {
return fmt.Errorf("unexpected nil of type %T", v)
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json
index 1acbf555e..b771b8271 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/generated.json
@@ -28,6 +28,7 @@
"api_op_AssignPrivateIpAddresses.go",
"api_op_AssignPrivateNatGatewayAddress.go",
"api_op_AssociateAddress.go",
+ "api_op_AssociateApplicationStatusCheck.go",
"api_op_AssociateCapacityReservationBillingOwner.go",
"api_op_AssociateClientVpnTargetNetwork.go",
"api_op_AssociateDhcpOptions.go",
@@ -74,6 +75,7 @@
"api_op_CopySnapshot.go",
"api_op_CopySnapshot_test.go",
"api_op_CopyVolumes.go",
+ "api_op_CreateApplicationStatusCheck.go",
"api_op_CreateCapacityManagerDataExport.go",
"api_op_CreateCapacityReservation.go",
"api_op_CreateCapacityReservationBySplitting.go",
@@ -180,6 +182,7 @@
"api_op_CreateVpnConnection.go",
"api_op_CreateVpnConnectionRoute.go",
"api_op_CreateVpnGateway.go",
+ "api_op_DeleteApplicationStatusCheck.go",
"api_op_DeleteCapacityManagerDataExport.go",
"api_op_DeleteCarrierGateway.go",
"api_op_DeleteClientVpnEndpoint.go",
@@ -288,6 +291,9 @@
"api_op_DescribeAddresses.go",
"api_op_DescribeAddressesAttribute.go",
"api_op_DescribeAggregateIdFormat.go",
+ "api_op_DescribeApplicationStatus.go",
+ "api_op_DescribeApplicationStatusCheckAssociations.go",
+ "api_op_DescribeApplicationStatusChecks.go",
"api_op_DescribeAvailabilityZones.go",
"api_op_DescribeAwsNetworkPerformanceMetricSubscriptions.go",
"api_op_DescribeBundleTasks.go",
@@ -479,6 +485,7 @@
"api_op_DetachVpnGateway.go",
"api_op_DisableAddressTransfer.go",
"api_op_DisableAllowedImagesSettings.go",
+ "api_op_DisableApplicationStatusCheckSuppression.go",
"api_op_DisableAwsNetworkPerformanceMetricSubscription.go",
"api_op_DisableCapacityManager.go",
"api_op_DisableEbsEncryptionByDefault.go",
@@ -499,6 +506,7 @@
"api_op_DisableVpcClassicLink.go",
"api_op_DisableVpcClassicLinkDnsSupport.go",
"api_op_DisassociateAddress.go",
+ "api_op_DisassociateApplicationStatusCheck.go",
"api_op_DisassociateCapacityReservationBillingOwner.go",
"api_op_DisassociateClientVpnTargetNetwork.go",
"api_op_DisassociateEnclaveCertificateIamRole.go",
@@ -518,6 +526,7 @@
"api_op_DisassociateVpcCidrBlock.go",
"api_op_EnableAddressTransfer.go",
"api_op_EnableAllowedImagesSettings.go",
+ "api_op_EnableApplicationStatusCheckSuppression.go",
"api_op_EnableAwsNetworkPerformanceMetricSubscription.go",
"api_op_EnableCapacityManager.go",
"api_op_EnableEbsEncryptionByDefault.go",
@@ -626,6 +635,7 @@
"api_op_LockSnapshot.go",
"api_op_ModifyAccountVpcEncryptionControl.go",
"api_op_ModifyAddressAttribute.go",
+ "api_op_ModifyApplicationStatusCheck.go",
"api_op_ModifyAvailabilityZoneGroup.go",
"api_op_ModifyCapacityReservation.go",
"api_op_ModifyCapacityReservationFleet.go",
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go
index 997922f17..07407c3a1 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/go_module_metadata.go
@@ -3,4 +3,4 @@
package ec2
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.318.1"
+const goModuleVersion = "1.319.1"
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go
index 75f6f885b..c565d016d 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/serializers.go
@@ -1278,6 +1278,76 @@ func (m *awsEc2query_serializeOpAssociateAddress) HandleSerialize(ctx context.Co
return next.HandleSerialize(ctx, in)
}
+type awsEc2query_serializeOpAssociateApplicationStatusCheck struct {
+}
+
+func (*awsEc2query_serializeOpAssociateApplicationStatusCheck) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpAssociateApplicationStatusCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*AssociateApplicationStatusCheckInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("AssociateApplicationStatusCheck")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentAssociateApplicationStatusCheckInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
type awsEc2query_serializeOpAssociateCapacityReservationBillingOwner struct {
}
@@ -4428,6 +4498,76 @@ func (m *awsEc2query_serializeOpCopyVolumes) HandleSerialize(ctx context.Context
return next.HandleSerialize(ctx, in)
}
+type awsEc2query_serializeOpCreateApplicationStatusCheck struct {
+}
+
+func (*awsEc2query_serializeOpCreateApplicationStatusCheck) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpCreateApplicationStatusCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*CreateApplicationStatusCheckInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("CreateApplicationStatusCheck")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentCreateApplicationStatusCheckInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
type awsEc2query_serializeOpCreateCapacityManagerDataExport struct {
}
@@ -11848,6 +11988,76 @@ func (m *awsEc2query_serializeOpCreateVpnGateway) HandleSerialize(ctx context.Co
return next.HandleSerialize(ctx, in)
}
+type awsEc2query_serializeOpDeleteApplicationStatusCheck struct {
+}
+
+func (*awsEc2query_serializeOpDeleteApplicationStatusCheck) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpDeleteApplicationStatusCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*DeleteApplicationStatusCheckInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("DeleteApplicationStatusCheck")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentDeleteApplicationStatusCheckInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
type awsEc2query_serializeOpDeleteCapacityManagerDataExport struct {
}
@@ -19408,14 +19618,14 @@ func (m *awsEc2query_serializeOpDescribeAggregateIdFormat) HandleSerialize(ctx c
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeAvailabilityZones struct {
+type awsEc2query_serializeOpDescribeApplicationStatus struct {
}
-func (*awsEc2query_serializeOpDescribeAvailabilityZones) ID() string {
+func (*awsEc2query_serializeOpDescribeApplicationStatus) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeAvailabilityZones) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeApplicationStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19427,7 +19637,7 @@ func (m *awsEc2query_serializeOpDescribeAvailabilityZones) HandleSerialize(ctx c
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeAvailabilityZonesInput)
+ input, ok := in.Parameters.(*DescribeApplicationStatusInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19452,10 +19662,10 @@ func (m *awsEc2query_serializeOpDescribeAvailabilityZones) HandleSerialize(ctx c
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeAvailabilityZones")
+ body.Key("Action").String("DescribeApplicationStatus")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeAvailabilityZonesInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeApplicationStatusInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -19478,14 +19688,14 @@ func (m *awsEc2query_serializeOpDescribeAvailabilityZones) HandleSerialize(ctx c
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions struct {
+type awsEc2query_serializeOpDescribeApplicationStatusCheckAssociations struct {
}
-func (*awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) ID() string {
+func (*awsEc2query_serializeOpDescribeApplicationStatusCheckAssociations) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeApplicationStatusCheckAssociations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19497,7 +19707,7 @@ func (m *awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeAwsNetworkPerformanceMetricSubscriptionsInput)
+ input, ok := in.Parameters.(*DescribeApplicationStatusCheckAssociationsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19522,10 +19732,10 @@ func (m *awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeAwsNetworkPerformanceMetricSubscriptions")
+ body.Key("Action").String("DescribeApplicationStatusCheckAssociations")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeAwsNetworkPerformanceMetricSubscriptionsInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeApplicationStatusCheckAssociationsInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -19548,14 +19758,14 @@ func (m *awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeBundleTasks struct {
+type awsEc2query_serializeOpDescribeApplicationStatusChecks struct {
}
-func (*awsEc2query_serializeOpDescribeBundleTasks) ID() string {
+func (*awsEc2query_serializeOpDescribeApplicationStatusChecks) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeBundleTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeApplicationStatusChecks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19567,7 +19777,7 @@ func (m *awsEc2query_serializeOpDescribeBundleTasks) HandleSerialize(ctx context
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeBundleTasksInput)
+ input, ok := in.Parameters.(*DescribeApplicationStatusChecksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19592,10 +19802,10 @@ func (m *awsEc2query_serializeOpDescribeBundleTasks) HandleSerialize(ctx context
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeBundleTasks")
+ body.Key("Action").String("DescribeApplicationStatusChecks")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeBundleTasksInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeApplicationStatusChecksInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -19618,14 +19828,14 @@ func (m *awsEc2query_serializeOpDescribeBundleTasks) HandleSerialize(ctx context
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeByoipCidrs struct {
+type awsEc2query_serializeOpDescribeAvailabilityZones struct {
}
-func (*awsEc2query_serializeOpDescribeByoipCidrs) ID() string {
+func (*awsEc2query_serializeOpDescribeAvailabilityZones) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeByoipCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeAvailabilityZones) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19637,7 +19847,7 @@ func (m *awsEc2query_serializeOpDescribeByoipCidrs) HandleSerialize(ctx context.
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeByoipCidrsInput)
+ input, ok := in.Parameters.(*DescribeAvailabilityZonesInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19662,10 +19872,10 @@ func (m *awsEc2query_serializeOpDescribeByoipCidrs) HandleSerialize(ctx context.
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeByoipCidrs")
+ body.Key("Action").String("DescribeAvailabilityZones")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeByoipCidrsInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeAvailabilityZonesInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -19688,14 +19898,14 @@ func (m *awsEc2query_serializeOpDescribeByoipCidrs) HandleSerialize(ctx context.
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory struct {
+type awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions struct {
}
-func (*awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) ID() string {
+func (*awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeAwsNetworkPerformanceMetricSubscriptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19707,7 +19917,7 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) HandleSer
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeCapacityBlockExtensionHistoryInput)
+ input, ok := in.Parameters.(*DescribeAwsNetworkPerformanceMetricSubscriptionsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19732,10 +19942,10 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) HandleSer
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeCapacityBlockExtensionHistory")
+ body.Key("Action").String("DescribeAwsNetworkPerformanceMetricSubscriptions")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeCapacityBlockExtensionHistoryInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeAwsNetworkPerformanceMetricSubscriptionsInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -19758,14 +19968,14 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) HandleSer
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings struct {
+type awsEc2query_serializeOpDescribeBundleTasks struct {
}
-func (*awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) ID() string {
+func (*awsEc2query_serializeOpDescribeBundleTasks) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeBundleTasks) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19777,7 +19987,7 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) HandleS
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeCapacityBlockExtensionOfferingsInput)
+ input, ok := in.Parameters.(*DescribeBundleTasksInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19802,10 +20012,10 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) HandleS
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeCapacityBlockExtensionOfferings")
+ body.Key("Action").String("DescribeBundleTasks")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeCapacityBlockExtensionOfferingsInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeBundleTasksInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -19828,14 +20038,14 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) HandleS
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDescribeCapacityBlockOfferings struct {
+type awsEc2query_serializeOpDescribeByoipCidrs struct {
}
-func (*awsEc2query_serializeOpDescribeCapacityBlockOfferings) ID() string {
+func (*awsEc2query_serializeOpDescribeByoipCidrs) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDescribeCapacityBlockOfferings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDescribeByoipCidrs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -19847,7 +20057,7 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockOfferings) HandleSerialize(
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DescribeCapacityBlockOfferingsInput)
+ input, ok := in.Parameters.(*DescribeByoipCidrsInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -19872,10 +20082,220 @@ func (m *awsEc2query_serializeOpDescribeCapacityBlockOfferings) HandleSerialize(
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DescribeCapacityBlockOfferings")
+ body.Key("Action").String("DescribeByoipCidrs")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDescribeCapacityBlockOfferingsInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDescribeByoipCidrsInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
+type awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory struct {
+}
+
+func (*awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionHistory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*DescribeCapacityBlockExtensionHistoryInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("DescribeCapacityBlockExtensionHistory")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentDescribeCapacityBlockExtensionHistoryInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
+type awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings struct {
+}
+
+func (*awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpDescribeCapacityBlockExtensionOfferings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*DescribeCapacityBlockExtensionOfferingsInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("DescribeCapacityBlockExtensionOfferings")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentDescribeCapacityBlockExtensionOfferingsInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
+type awsEc2query_serializeOpDescribeCapacityBlockOfferings struct {
+}
+
+func (*awsEc2query_serializeOpDescribeCapacityBlockOfferings) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpDescribeCapacityBlockOfferings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*DescribeCapacityBlockOfferingsInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("DescribeCapacityBlockOfferings")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentDescribeCapacityBlockOfferingsInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -32778,14 +33198,14 @@ func (m *awsEc2query_serializeOpDisableAllowedImagesSettings) HandleSerialize(ct
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription struct {
+type awsEc2query_serializeOpDisableApplicationStatusCheckSuppression struct {
}
-func (*awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string {
+func (*awsEc2query_serializeOpDisableApplicationStatusCheckSuppression) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDisableApplicationStatusCheckSuppression) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -32797,7 +33217,7 @@ func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription)
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DisableAwsNetworkPerformanceMetricSubscriptionInput)
+ input, ok := in.Parameters.(*DisableApplicationStatusCheckSuppressionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -32822,10 +33242,10 @@ func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription)
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DisableAwsNetworkPerformanceMetricSubscription")
+ body.Key("Action").String("DisableApplicationStatusCheckSuppression")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDisableApplicationStatusCheckSuppressionInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -32848,14 +33268,14 @@ func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription)
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDisableCapacityManager struct {
+type awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription struct {
}
-func (*awsEc2query_serializeOpDisableCapacityManager) ID() string {
+func (*awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDisableAwsNetworkPerformanceMetricSubscription) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -32867,7 +33287,7 @@ func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx cont
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DisableCapacityManagerInput)
+ input, ok := in.Parameters.(*DisableAwsNetworkPerformanceMetricSubscriptionInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -32892,10 +33312,10 @@ func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx cont
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DisableCapacityManager")
+ body.Key("Action").String("DisableAwsNetworkPerformanceMetricSubscription")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDisableCapacityManagerInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -32918,14 +33338,14 @@ func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx cont
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDisableEbsEncryptionByDefault struct {
+type awsEc2query_serializeOpDisableCapacityManager struct {
}
-func (*awsEc2query_serializeOpDisableEbsEncryptionByDefault) ID() string {
+func (*awsEc2query_serializeOpDisableCapacityManager) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDisableCapacityManager) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -32937,7 +33357,7 @@ func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(c
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DisableEbsEncryptionByDefaultInput)
+ input, ok := in.Parameters.(*DisableCapacityManagerInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -32962,10 +33382,10 @@ func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(c
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DisableEbsEncryptionByDefault")
+ body.Key("Action").String("DisableCapacityManager")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDisableEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDisableCapacityManagerInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -32988,14 +33408,14 @@ func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(c
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDisableFastLaunch struct {
+type awsEc2query_serializeOpDisableEbsEncryptionByDefault struct {
}
-func (*awsEc2query_serializeOpDisableFastLaunch) ID() string {
+func (*awsEc2query_serializeOpDisableEbsEncryptionByDefault) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDisableEbsEncryptionByDefault) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -33007,7 +33427,7 @@ func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.C
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DisableFastLaunchInput)
+ input, ok := in.Parameters.(*DisableEbsEncryptionByDefaultInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -33032,10 +33452,10 @@ func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.C
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("DisableFastLaunch")
+ body.Key("Action").String("DisableEbsEncryptionByDefault")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentDisableFastLaunchInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentDisableEbsEncryptionByDefaultInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -33058,14 +33478,14 @@ func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.C
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpDisableFastSnapshotRestores struct {
+type awsEc2query_serializeOpDisableFastLaunch struct {
}
-func (*awsEc2query_serializeOpDisableFastSnapshotRestores) ID() string {
+func (*awsEc2query_serializeOpDisableFastLaunch) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpDisableFastLaunch) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -33077,7 +33497,77 @@ func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*DisableFastSnapshotRestoresInput)
+ input, ok := in.Parameters.(*DisableFastLaunchInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("DisableFastLaunch")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentDisableFastLaunchInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
+type awsEc2query_serializeOpDisableFastSnapshotRestores struct {
+}
+
+func (*awsEc2query_serializeOpDisableFastSnapshotRestores) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpDisableFastSnapshotRestores) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*DisableFastSnapshotRestoresInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -34178,6 +34668,76 @@ func (m *awsEc2query_serializeOpDisassociateAddress) HandleSerialize(ctx context
return next.HandleSerialize(ctx, in)
}
+type awsEc2query_serializeOpDisassociateApplicationStatusCheck struct {
+}
+
+func (*awsEc2query_serializeOpDisassociateApplicationStatusCheck) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpDisassociateApplicationStatusCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*DisassociateApplicationStatusCheckInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("DisassociateApplicationStatusCheck")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentDisassociateApplicationStatusCheckInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
type awsEc2query_serializeOpDisassociateCapacityReservationBillingOwner struct {
}
@@ -35508,6 +36068,76 @@ func (m *awsEc2query_serializeOpEnableAllowedImagesSettings) HandleSerialize(ctx
return next.HandleSerialize(ctx, in)
}
+type awsEc2query_serializeOpEnableApplicationStatusCheckSuppression struct {
+}
+
+func (*awsEc2query_serializeOpEnableApplicationStatusCheckSuppression) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpEnableApplicationStatusCheckSuppression) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*EnableApplicationStatusCheckSuppressionInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("EnableApplicationStatusCheckSuppression")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentEnableApplicationStatusCheckSuppressionInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
type awsEc2query_serializeOpEnableAwsNetworkPerformanceMetricSubscription struct {
}
@@ -43068,14 +43698,14 @@ func (m *awsEc2query_serializeOpModifyAddressAttribute) HandleSerialize(ctx cont
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpModifyAvailabilityZoneGroup struct {
+type awsEc2query_serializeOpModifyApplicationStatusCheck struct {
}
-func (*awsEc2query_serializeOpModifyAvailabilityZoneGroup) ID() string {
+func (*awsEc2query_serializeOpModifyApplicationStatusCheck) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpModifyApplicationStatusCheck) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -43087,7 +43717,7 @@ func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*ModifyAvailabilityZoneGroupInput)
+ input, ok := in.Parameters.(*ModifyApplicationStatusCheckInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -43112,10 +43742,10 @@ func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("ModifyAvailabilityZoneGroup")
+ body.Key("Action").String("ModifyApplicationStatusCheck")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentModifyAvailabilityZoneGroupInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentModifyApplicationStatusCheckInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -43138,14 +43768,14 @@ func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpModifyCapacityReservation struct {
+type awsEc2query_serializeOpModifyAvailabilityZoneGroup struct {
}
-func (*awsEc2query_serializeOpModifyCapacityReservation) ID() string {
+func (*awsEc2query_serializeOpModifyAvailabilityZoneGroup) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpModifyAvailabilityZoneGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -43157,7 +43787,7 @@ func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx c
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*ModifyCapacityReservationInput)
+ input, ok := in.Parameters.(*ModifyAvailabilityZoneGroupInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -43182,10 +43812,10 @@ func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx c
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("ModifyCapacityReservation")
+ body.Key("Action").String("ModifyAvailabilityZoneGroup")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentModifyCapacityReservationInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentModifyAvailabilityZoneGroupInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -43208,14 +43838,14 @@ func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx c
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpModifyCapacityReservationFleet struct {
+type awsEc2query_serializeOpModifyCapacityReservation struct {
}
-func (*awsEc2query_serializeOpModifyCapacityReservationFleet) ID() string {
+func (*awsEc2query_serializeOpModifyCapacityReservation) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpModifyCapacityReservation) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -43227,7 +43857,7 @@ func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*ModifyCapacityReservationFleetInput)
+ input, ok := in.Parameters.(*ModifyCapacityReservationInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -43252,10 +43882,10 @@ func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("ModifyCapacityReservationFleet")
+ body.Key("Action").String("ModifyCapacityReservation")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentModifyCapacityReservationFleetInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentModifyCapacityReservationInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -43278,14 +43908,14 @@ func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpModifyClientVpnEndpoint struct {
+type awsEc2query_serializeOpModifyCapacityReservationFleet struct {
}
-func (*awsEc2query_serializeOpModifyClientVpnEndpoint) ID() string {
+func (*awsEc2query_serializeOpModifyCapacityReservationFleet) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpModifyCapacityReservationFleet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -43297,7 +43927,7 @@ func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx con
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*ModifyClientVpnEndpointInput)
+ input, ok := in.Parameters.(*ModifyCapacityReservationFleetInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -43322,10 +43952,10 @@ func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx con
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("ModifyClientVpnEndpoint")
+ body.Key("Action").String("ModifyCapacityReservationFleet")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentModifyClientVpnEndpointInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentModifyCapacityReservationFleetInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -43348,14 +43978,14 @@ func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx con
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpModifyDefaultCreditSpecification struct {
+type awsEc2query_serializeOpModifyClientVpnEndpoint struct {
}
-func (*awsEc2query_serializeOpModifyDefaultCreditSpecification) ID() string {
+func (*awsEc2query_serializeOpModifyClientVpnEndpoint) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpModifyClientVpnEndpoint) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -43367,7 +43997,7 @@ func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerializ
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*ModifyDefaultCreditSpecificationInput)
+ input, ok := in.Parameters.(*ModifyClientVpnEndpointInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -43392,10 +44022,10 @@ func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerializ
bodyWriter := bytes.NewBuffer(nil)
bodyEncoder := query.NewEncoder(bodyWriter)
body := bodyEncoder.Object()
- body.Key("Action").String("ModifyDefaultCreditSpecification")
+ body.Key("Action").String("ModifyClientVpnEndpoint")
body.Key("Version").String("2016-11-15")
- if err := awsEc2query_serializeOpDocumentModifyDefaultCreditSpecificationInput(input, bodyEncoder.Value); err != nil {
+ if err := awsEc2query_serializeOpDocumentModifyClientVpnEndpointInput(input, bodyEncoder.Value); err != nil {
return out, metadata, &smithy.SerializationError{Err: err}
}
@@ -43418,14 +44048,14 @@ func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerializ
return next.HandleSerialize(ctx, in)
}
-type awsEc2query_serializeOpModifyEbsDefaultKmsKeyId struct {
+type awsEc2query_serializeOpModifyDefaultCreditSpecification struct {
}
-func (*awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) ID() string {
+func (*awsEc2query_serializeOpModifyDefaultCreditSpecification) ID() string {
return "OperationSerializer"
}
-func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+func (m *awsEc2query_serializeOpModifyDefaultCreditSpecification) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
out middleware.SerializeOutput, metadata middleware.Metadata, err error,
) {
_, span := tracing.StartSpan(ctx, "OperationSerializer")
@@ -43437,7 +44067,77 @@ func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx co
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
}
- input, ok := in.Parameters.(*ModifyEbsDefaultKmsKeyIdInput)
+ input, ok := in.Parameters.(*ModifyDefaultCreditSpecificationInput)
+ _ = input
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
+ }
+
+ operationPath := "/"
+ if len(request.Request.URL.Path) == 0 {
+ request.Request.URL.Path = operationPath
+ } else {
+ request.Request.URL.Path = path.Join(request.Request.URL.Path, operationPath)
+ if request.Request.URL.Path != "/" && operationPath[len(operationPath)-1] == '/' {
+ request.Request.URL.Path += "/"
+ }
+ }
+ request.Request.Method = "POST"
+ httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded")
+
+ bodyWriter := bytes.NewBuffer(nil)
+ bodyEncoder := query.NewEncoder(bodyWriter)
+ body := bodyEncoder.Object()
+ body.Key("Action").String("ModifyDefaultCreditSpecification")
+ body.Key("Version").String("2016-11-15")
+
+ if err := awsEc2query_serializeOpDocumentModifyDefaultCreditSpecificationInput(input, bodyEncoder.Value); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ err = bodyEncoder.Encode()
+ if err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+
+ if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
+ return out, metadata, &smithy.SerializationError{Err: err}
+ }
+ in.Request = request
+
+ endTimer()
+ span.End()
+ return next.HandleSerialize(ctx, in)
+}
+
+type awsEc2query_serializeOpModifyEbsDefaultKmsKeyId struct {
+}
+
+func (*awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) ID() string {
+ return "OperationSerializer"
+}
+
+func (m *awsEc2query_serializeOpModifyEbsDefaultKmsKeyId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
+ out middleware.SerializeOutput, metadata middleware.Metadata, err error,
+) {
+ _, span := tracing.StartSpan(ctx, "OperationSerializer")
+ endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
+ defer endTimer()
+ defer span.End()
+ request, ok := in.Request.(*smithyhttp.Request)
+ if !ok {
+ return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
+ }
+
+ input, ok := in.Parameters.(*ModifyEbsDefaultKmsKeyIdInput)
_ = input
if !ok {
return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
@@ -54555,6 +55255,19 @@ func awsEc2query_serializeDocumentAllowedInstanceTypeSet(v []string, value query
return nil
}
+func awsEc2query_serializeDocumentApplicationStatusCheckIdList(v []string, value query.Value) error {
+ if len(v) == 0 {
+ return nil
+ }
+ array := value.Array("Item")
+
+ for i := range v {
+ av := array.Value()
+ av.String(v[i])
+ }
+ return nil
+}
+
func awsEc2query_serializeDocumentArchitectureTypeSet(v []types.ArchitectureType, value query.Value) error {
if len(v) == 0 {
return nil
@@ -55980,6 +56693,38 @@ func awsEc2query_serializeDocumentCustomerGatewayIdStringList(v []string, value
return nil
}
+func awsEc2query_serializeDocumentCustomKeyValuePairRequestSet(v []types.CustomTagKeyValueRequestPair, value query.Value) error {
+ if len(v) == 0 {
+ return nil
+ }
+ array := value.Array("Item")
+
+ for i := range v {
+ av := array.Value()
+ if err := awsEc2query_serializeDocumentCustomTagKeyValueRequestPair(&v[i], av); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func awsEc2query_serializeDocumentCustomTagKeyValueRequestPair(v *types.CustomTagKeyValueRequestPair, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.Key != nil {
+ objectKey := object.Key("Key")
+ objectKey.String(*v.Key)
+ }
+
+ if v.Value != nil {
+ objectKey := object.Key("Value")
+ objectKey.String(*v.Value)
+ }
+
+ return nil
+}
+
func awsEc2query_serializeDocumentDataQueries(v []types.DataQuery, value query.Value) error {
if len(v) == 0 {
return nil
@@ -57320,6 +58065,91 @@ func awsEc2query_serializeDocumentGroupNameStringList(v []string, value query.Va
return nil
}
+func awsEc2query_serializeDocumentHealthCheckPathDestinationRequestObject(v *types.HealthCheckPathDestinationRequestObject, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.SecurityGroupId != nil {
+ objectKey := object.Key("SecurityGroupId")
+ objectKey.String(*v.SecurityGroupId)
+ }
+
+ if v.SubnetId != nil {
+ objectKey := object.Key("SubnetId")
+ objectKey.String(*v.SubnetId)
+ }
+
+ return nil
+}
+
+func awsEc2query_serializeDocumentHealthCheckPathDestinationRequestSet(v []types.HealthCheckPathDestinationRequestObject, value query.Value) error {
+ if len(v) == 0 {
+ return nil
+ }
+ array := value.Array("Item")
+
+ for i := range v {
+ av := array.Value()
+ if err := awsEc2query_serializeDocumentHealthCheckPathDestinationRequestObject(&v[i], av); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func awsEc2query_serializeDocumentHealthCheckPathRequestList(v []types.HealthCheckPathRequestObject, value query.Value) error {
+ if len(v) == 0 {
+ return nil
+ }
+ array := value.Array("Item")
+
+ for i := range v {
+ av := array.Value()
+ if err := awsEc2query_serializeDocumentHealthCheckPathRequestObject(&v[i], av); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func awsEc2query_serializeDocumentHealthCheckPathRequestObject(v *types.HealthCheckPathRequestObject, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.Destinations != nil {
+ objectKey := object.FlatKey("Destination")
+ if err := awsEc2query_serializeDocumentHealthCheckPathDestinationRequestSet(v.Destinations, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.Source != nil {
+ objectKey := object.Key("Source")
+ if err := awsEc2query_serializeDocumentHealthCheckPathSourceRequestObject(v.Source, objectKey); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func awsEc2query_serializeDocumentHealthCheckPathSourceRequestObject(v *types.HealthCheckPathSourceRequestObject, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.SecurityGroupId != nil {
+ objectKey := object.Key("SecurityGroupId")
+ objectKey.String(*v.SecurityGroupId)
+ }
+
+ if v.SubnetId != nil {
+ objectKey := object.Key("SubnetId")
+ objectKey.String(*v.SubnetId)
+ }
+
+ return nil
+}
+
func awsEc2query_serializeDocumentHibernationOptionsRequest(v *types.HibernationOptionsRequest, value query.Value) error {
object := value.Object()
_ = object
@@ -66981,6 +67811,42 @@ func awsEc2query_serializeOpDocumentAssociateAddressInput(v *AssociateAddressInp
return nil
}
+func awsEc2query_serializeOpDocumentAssociateApplicationStatusCheckInput(v *AssociateApplicationStatusCheckInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ApplicationStatusCheckId != nil {
+ objectKey := object.Key("ApplicationStatusCheckId")
+ objectKey.String(*v.ApplicationStatusCheckId)
+ }
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.InstanceIds != nil {
+ objectKey := object.FlatKey("InstanceId")
+ if err := awsEc2query_serializeDocumentInstanceIdList(v.InstanceIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.TargetTagAssociations != nil {
+ objectKey := object.FlatKey("TargetTagAssociation")
+ if err := awsEc2query_serializeDocumentCustomKeyValuePairRequestSet(v.TargetTagAssociations, objectKey); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentAssociateCapacityReservationBillingOwnerInput(v *AssociateCapacityReservationBillingOwnerInput, value query.Value) error {
object := value.Object()
_ = object
@@ -68354,6 +69220,102 @@ func awsEc2query_serializeOpDocumentCopyVolumesInput(v *CopyVolumesInput, value
return nil
}
+func awsEc2query_serializeOpDocumentCreateApplicationStatusCheckInput(v *CreateApplicationStatusCheckInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if len(v.Aggregation) > 0 {
+ objectKey := object.Key("Aggregation")
+ objectKey.String(string(v.Aggregation))
+ }
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DeviceIndex != nil {
+ objectKey := object.Key("DeviceIndex")
+ objectKey.Integer(*v.DeviceIndex)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.FailureThreshold != nil {
+ objectKey := object.Key("FailureThreshold")
+ objectKey.Integer(*v.FailureThreshold)
+ }
+
+ if v.HealthCheckPaths != nil {
+ objectKey := object.FlatKey("HealthCheckPath")
+ if err := awsEc2query_serializeDocumentHealthCheckPathRequestList(v.HealthCheckPaths, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.InitializationGracePeriodSeconds != nil {
+ objectKey := object.Key("InitializationGracePeriodSeconds")
+ objectKey.Integer(*v.InitializationGracePeriodSeconds)
+ }
+
+ if v.Interval != nil {
+ objectKey := object.Key("Interval")
+ objectKey.Integer(*v.Interval)
+ }
+
+ if len(v.IpScope) > 0 {
+ objectKey := object.Key("IpScope")
+ objectKey.String(string(v.IpScope))
+ }
+
+ if len(v.IpVersion) > 0 {
+ objectKey := object.Key("IpVersion")
+ objectKey.String(string(v.IpVersion))
+ }
+
+ if v.Path != nil {
+ objectKey := object.Key("Path")
+ objectKey.String(*v.Path)
+ }
+
+ if v.Port != nil {
+ objectKey := object.Key("Port")
+ objectKey.Integer(*v.Port)
+ }
+
+ if len(v.Protocol) > 0 {
+ objectKey := object.Key("Protocol")
+ objectKey.String(string(v.Protocol))
+ }
+
+ if v.StatusCodeMatcher != nil {
+ objectKey := object.Key("StatusCodeMatcher")
+ objectKey.String(*v.StatusCodeMatcher)
+ }
+
+ if v.SuccessThreshold != nil {
+ objectKey := object.Key("SuccessThreshold")
+ objectKey.Integer(*v.SuccessThreshold)
+ }
+
+ if v.TagSpecifications != nil {
+ objectKey := object.FlatKey("TagSpecification")
+ if err := awsEc2query_serializeDocumentTagSpecificationList(v.TagSpecifications, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.Timeout != nil {
+ objectKey := object.Key("Timeout")
+ objectKey.Integer(*v.Timeout)
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentCreateCapacityManagerDataExportInput(v *CreateCapacityManagerDataExportInput, value query.Value) error {
object := value.Object()
_ = object
@@ -73202,6 +74164,28 @@ func awsEc2query_serializeOpDocumentCreateVpnGatewayInput(v *CreateVpnGatewayInp
return nil
}
+func awsEc2query_serializeOpDocumentDeleteApplicationStatusCheckInput(v *DeleteApplicationStatusCheckInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ApplicationStatusCheckId != nil {
+ objectKey := object.Key("ApplicationStatusCheckId")
+ objectKey.String(*v.ApplicationStatusCheckId)
+ }
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentDeleteCapacityManagerDataExportInput(v *DeleteCapacityManagerDataExportInput, value query.Value) error {
object := value.Object()
_ = object
@@ -75294,6 +76278,119 @@ func awsEc2query_serializeOpDocumentDescribeAggregateIdFormatInput(v *DescribeAg
return nil
}
+func awsEc2query_serializeOpDocumentDescribeApplicationStatusCheckAssociationsInput(v *DescribeApplicationStatusCheckAssociationsInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ApplicationStatusCheckIds != nil {
+ objectKey := object.FlatKey("ApplicationStatusCheckId")
+ if err := awsEc2query_serializeDocumentApplicationStatusCheckIdList(v.ApplicationStatusCheckIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.Filters != nil {
+ objectKey := object.FlatKey("Filter")
+ if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.MaxResults != nil {
+ objectKey := object.Key("MaxResults")
+ objectKey.Integer(*v.MaxResults)
+ }
+
+ if v.NextToken != nil {
+ objectKey := object.Key("NextToken")
+ objectKey.String(*v.NextToken)
+ }
+
+ return nil
+}
+
+func awsEc2query_serializeOpDocumentDescribeApplicationStatusChecksInput(v *DescribeApplicationStatusChecksInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ApplicationStatusCheckIds != nil {
+ objectKey := object.FlatKey("ApplicationStatusCheckId")
+ if err := awsEc2query_serializeDocumentApplicationStatusCheckIdList(v.ApplicationStatusCheckIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.Filters != nil {
+ objectKey := object.FlatKey("Filter")
+ if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.IncludeAll != nil {
+ objectKey := object.Key("IncludeAll")
+ objectKey.Boolean(*v.IncludeAll)
+ }
+
+ if v.MaxResults != nil {
+ objectKey := object.Key("MaxResults")
+ objectKey.Integer(*v.MaxResults)
+ }
+
+ if v.NextToken != nil {
+ objectKey := object.Key("NextToken")
+ objectKey.String(*v.NextToken)
+ }
+
+ return nil
+}
+
+func awsEc2query_serializeOpDocumentDescribeApplicationStatusInput(v *DescribeApplicationStatusInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.Filters != nil {
+ objectKey := object.FlatKey("Filter")
+ if err := awsEc2query_serializeDocumentFilterList(v.Filters, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.InstanceIds != nil {
+ objectKey := object.FlatKey("InstanceId")
+ if err := awsEc2query_serializeDocumentInstanceIdList(v.InstanceIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.MaxResults != nil {
+ objectKey := object.Key("MaxResults")
+ objectKey.Integer(*v.MaxResults)
+ }
+
+ if v.NextToken != nil {
+ objectKey := object.Key("NextToken")
+ objectKey.String(*v.NextToken)
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentDescribeAvailabilityZonesInput(v *DescribeAvailabilityZonesInput, value query.Value) error {
object := value.Object()
_ = object
@@ -81923,6 +83020,30 @@ func awsEc2query_serializeOpDocumentDisableAllowedImagesSettingsInput(v *Disable
return nil
}
+func awsEc2query_serializeOpDocumentDisableApplicationStatusCheckSuppressionInput(v *DisableApplicationStatusCheckSuppressionInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.InstanceIds != nil {
+ objectKey := object.FlatKey("InstanceId")
+ if err := awsEc2query_serializeDocumentInstanceIdList(v.InstanceIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentDisableAwsNetworkPerformanceMetricSubscriptionInput(v *DisableAwsNetworkPerformanceMetricSubscriptionInput, value query.Value) error {
object := value.Object()
_ = object
@@ -82306,6 +83427,42 @@ func awsEc2query_serializeOpDocumentDisassociateAddressInput(v *DisassociateAddr
return nil
}
+func awsEc2query_serializeOpDocumentDisassociateApplicationStatusCheckInput(v *DisassociateApplicationStatusCheckInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ApplicationStatusCheckId != nil {
+ objectKey := object.Key("ApplicationStatusCheckId")
+ objectKey.String(*v.ApplicationStatusCheckId)
+ }
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.InstanceIds != nil {
+ objectKey := object.FlatKey("InstanceId")
+ if err := awsEc2query_serializeDocumentInstanceIdList(v.InstanceIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.TargetTagAssociations != nil {
+ objectKey := object.FlatKey("TargetTagAssociation")
+ if err := awsEc2query_serializeDocumentCustomKeyValuePairRequestSet(v.TargetTagAssociations, objectKey); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentDisassociateCapacityReservationBillingOwnerInput(v *DisassociateCapacityReservationBillingOwnerInput, value query.Value) error {
object := value.Object()
_ = object
@@ -82695,6 +83852,35 @@ func awsEc2query_serializeOpDocumentEnableAllowedImagesSettingsInput(v *EnableAl
return nil
}
+func awsEc2query_serializeOpDocumentEnableApplicationStatusCheckSuppressionInput(v *EnableApplicationStatusCheckSuppressionInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.DurationSeconds != nil {
+ objectKey := object.Key("DurationSeconds")
+ objectKey.Integer(*v.DurationSeconds)
+ }
+
+ if v.InstanceIds != nil {
+ objectKey := object.FlatKey("InstanceId")
+ if err := awsEc2query_serializeDocumentInstanceIdList(v.InstanceIds, objectKey); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentEnableAwsNetworkPerformanceMetricSubscriptionInput(v *EnableAwsNetworkPerformanceMetricSubscriptionInput, value query.Value) error {
object := value.Object()
_ = object
@@ -85711,6 +86897,100 @@ func awsEc2query_serializeOpDocumentModifyAddressAttributeInput(v *ModifyAddress
return nil
}
+func awsEc2query_serializeOpDocumentModifyApplicationStatusCheckInput(v *ModifyApplicationStatusCheckInput, value query.Value) error {
+ object := value.Object()
+ _ = object
+
+ if len(v.Aggregation) > 0 {
+ objectKey := object.Key("Aggregation")
+ objectKey.String(string(v.Aggregation))
+ }
+
+ if v.ApplicationStatusCheckId != nil {
+ objectKey := object.Key("ApplicationStatusCheckId")
+ objectKey.String(*v.ApplicationStatusCheckId)
+ }
+
+ if v.ClientToken != nil {
+ objectKey := object.Key("ClientToken")
+ objectKey.String(*v.ClientToken)
+ }
+
+ if v.DeviceIndex != nil {
+ objectKey := object.Key("DeviceIndex")
+ objectKey.Integer(*v.DeviceIndex)
+ }
+
+ if v.DryRun != nil {
+ objectKey := object.Key("DryRun")
+ objectKey.Boolean(*v.DryRun)
+ }
+
+ if v.FailureThreshold != nil {
+ objectKey := object.Key("FailureThreshold")
+ objectKey.Integer(*v.FailureThreshold)
+ }
+
+ if v.HealthCheckPaths != nil {
+ objectKey := object.FlatKey("HealthCheckPath")
+ if err := awsEc2query_serializeDocumentHealthCheckPathRequestList(v.HealthCheckPaths, objectKey); err != nil {
+ return err
+ }
+ }
+
+ if v.InitializationGracePeriodSeconds != nil {
+ objectKey := object.Key("InitializationGracePeriodSeconds")
+ objectKey.Integer(*v.InitializationGracePeriodSeconds)
+ }
+
+ if v.Interval != nil {
+ objectKey := object.Key("Interval")
+ objectKey.Integer(*v.Interval)
+ }
+
+ if len(v.IpScope) > 0 {
+ objectKey := object.Key("IpScope")
+ objectKey.String(string(v.IpScope))
+ }
+
+ if len(v.IpVersion) > 0 {
+ objectKey := object.Key("IpVersion")
+ objectKey.String(string(v.IpVersion))
+ }
+
+ if v.Path != nil {
+ objectKey := object.Key("Path")
+ objectKey.String(*v.Path)
+ }
+
+ if v.Port != nil {
+ objectKey := object.Key("Port")
+ objectKey.Integer(*v.Port)
+ }
+
+ if len(v.Protocol) > 0 {
+ objectKey := object.Key("Protocol")
+ objectKey.String(string(v.Protocol))
+ }
+
+ if v.StatusCodeMatcher != nil {
+ objectKey := object.Key("StatusCodeMatcher")
+ objectKey.String(*v.StatusCodeMatcher)
+ }
+
+ if v.SuccessThreshold != nil {
+ objectKey := object.Key("SuccessThreshold")
+ objectKey.Integer(*v.SuccessThreshold)
+ }
+
+ if v.Timeout != nil {
+ objectKey := object.Key("Timeout")
+ objectKey.Integer(*v.Timeout)
+ }
+
+ return nil
+}
+
func awsEc2query_serializeOpDocumentModifyAvailabilityZoneGroupInput(v *ModifyAvailabilityZoneGroupInput, value query.Value) error {
object := value.Object()
_ = object
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go
index b77cfc954..05f1e6566 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/enums.go
@@ -269,6 +269,25 @@ func (Affinity) Values() []Affinity {
}
}
+type AggregationStatusEnum string
+
+// Enum values for AggregationStatusEnum
+const (
+ AggregationStatusEnumIncluded AggregationStatusEnum = "included"
+ AggregationStatusEnumExcluded AggregationStatusEnum = "excluded"
+)
+
+// Values returns all known values for AggregationStatusEnum. Note that this can
+// be expanded in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (AggregationStatusEnum) Values() []AggregationStatusEnum {
+ return []AggregationStatusEnum{
+ "included",
+ "excluded",
+ }
+}
+
type AllocationState string
// Enum values for AllocationState
@@ -479,6 +498,58 @@ func (ApplianceModeSupportValue) Values() []ApplianceModeSupportValue {
}
}
+type ApplicationStatusCheckEnum string
+
+// Enum values for ApplicationStatusCheckEnum
+const (
+ ApplicationStatusCheckEnumPassed ApplicationStatusCheckEnum = "passed"
+ ApplicationStatusCheckEnumFailed ApplicationStatusCheckEnum = "failed"
+ ApplicationStatusCheckEnumInitializing ApplicationStatusCheckEnum = "initializing"
+ ApplicationStatusCheckEnumInsufficientData ApplicationStatusCheckEnum = "insufficient-data"
+ ApplicationStatusCheckEnumNotApplicable ApplicationStatusCheckEnum = "not-applicable"
+)
+
+// Values returns all known values for ApplicationStatusCheckEnum. Note that this
+// can be expanded in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (ApplicationStatusCheckEnum) Values() []ApplicationStatusCheckEnum {
+ return []ApplicationStatusCheckEnum{
+ "passed",
+ "failed",
+ "initializing",
+ "insufficient-data",
+ "not-applicable",
+ }
+}
+
+type ApplicationStatusEnum string
+
+// Enum values for ApplicationStatusEnum
+const (
+ ApplicationStatusEnumOk ApplicationStatusEnum = "ok"
+ ApplicationStatusEnumImpaired ApplicationStatusEnum = "impaired"
+ ApplicationStatusEnumInitializing ApplicationStatusEnum = "initializing"
+ ApplicationStatusEnumInsufficientData ApplicationStatusEnum = "insufficient-data"
+ ApplicationStatusEnumNotApplicable ApplicationStatusEnum = "not-applicable"
+ ApplicationStatusEnumSuppressed ApplicationStatusEnum = "suppressed"
+)
+
+// Values returns all known values for ApplicationStatusEnum. Note that this can
+// be expanded in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (ApplicationStatusEnum) Values() []ApplicationStatusEnum {
+ return []ApplicationStatusEnum{
+ "ok",
+ "impaired",
+ "initializing",
+ "insufficient-data",
+ "not-applicable",
+ "suppressed",
+ }
+}
+
type ApplyCancellationCharges string
// Enum values for ApplyCancellationCharges
@@ -642,6 +713,25 @@ func (AssociationStatusCode) Values() []AssociationStatusCode {
}
}
+type AssociationTypeEnum string
+
+// Enum values for AssociationTypeEnum
+const (
+ AssociationTypeEnumTag AssociationTypeEnum = "tag"
+ AssociationTypeEnumInstanceId AssociationTypeEnum = "instance-id"
+)
+
+// Values returns all known values for AssociationTypeEnum. Note that this can be
+// expanded in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (AssociationTypeEnum) Values() []AssociationTypeEnum {
+ return []AssociationTypeEnum{
+ "tag",
+ "instance-id",
+ }
+}
+
type AttachmentLimitType string
// Enum values for AttachmentLimitType
@@ -8071,6 +8161,23 @@ func (IpamTier) Values() []IpamTier {
}
}
+type IpScopeEnum string
+
+// Enum values for IpScopeEnum
+const (
+ IpScopeEnumPrivate IpScopeEnum = "private"
+)
+
+// Values returns all known values for IpScopeEnum. Note that this can be expanded
+// in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (IpScopeEnum) Values() []IpScopeEnum {
+ return []IpScopeEnum{
+ "private",
+ }
+}
+
type IpSource string
// Enum values for IpSource
@@ -8130,6 +8237,25 @@ func (Ipv6SupportValue) Values() []Ipv6SupportValue {
}
}
+type IpVersionEnum string
+
+// Enum values for IpVersionEnum
+const (
+ IpVersionEnumIpv4 IpVersionEnum = "ipv4"
+ IpVersionEnumIpv6 IpVersionEnum = "ipv6"
+)
+
+// Values returns all known values for IpVersionEnum. Note that this can be
+// expanded in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (IpVersionEnum) Values() []IpVersionEnum {
+ return []IpVersionEnum{
+ "ipv4",
+ "ipv6",
+ }
+}
+
type KeyFormat string
// Enum values for KeyFormat
@@ -9261,6 +9387,25 @@ func (NetworkInterfaceType) Values() []NetworkInterfaceType {
}
}
+type NetworkProtocolEnum string
+
+// Enum values for NetworkProtocolEnum
+const (
+ NetworkProtocolEnumHttp NetworkProtocolEnum = "http"
+ NetworkProtocolEnumHttps NetworkProtocolEnum = "https"
+)
+
+// Values returns all known values for NetworkProtocolEnum. Note that this can be
+// expanded in the future, and so it is only as up to date as the client.
+//
+// The ordering of this slice is not guaranteed to be stable across updates.
+func (NetworkProtocolEnum) Values() []NetworkProtocolEnum {
+ return []NetworkProtocolEnum{
+ "http",
+ "https",
+ }
+}
+
type NitroEnclavesSupport string
// Enum values for NitroEnclavesSupport
@@ -10194,6 +10339,7 @@ const (
ResourceTypeVpnConcentrator ResourceType = "vpn-concentrator"
ResourceTypeIpamPoolAllocation ResourceType = "ipam-pool-allocation"
ResourceTypeCapacityReservationCancellationQuote ResourceType = "capacity-reservation-cancellation-quote"
+ ResourceTypeApplicationStatusCheck ResourceType = "application-status-check"
)
// Values returns all known values for ResourceType. Note that this can be
@@ -10311,6 +10457,7 @@ func (ResourceType) Values() []ResourceType {
"vpn-concentrator",
"ipam-pool-allocation",
"capacity-reservation-cancellation-quote",
+ "application-status-check",
}
}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go
index 14e0a159a..0ee26d37c 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/types/types.go
@@ -698,6 +698,261 @@ type AnalysisSecurityGroupRule struct {
noSmithyDocumentSerde
}
+// Describes the application-level health status for an instance.
+type ApplicationStatus struct {
+
+ // Details about the application status checks for the instance.
+ Details []ApplicationStatusDetail
+
+ // The date and time when application status reporting resumes after suppression.
+ ResumeAt *time.Time
+
+ // The current instance-level application status. This status is derived from
+ // application status checks with Aggregation set to included . Possible values:
+ //
+ // - ok – All included checks passed.
+ //
+ // - impaired – At least one included check failed.
+ //
+ // - initializing – At least one included check is initializing, and no included
+ // check is impaired.
+ //
+ // - insufficient-data – At least one included check has insufficient data, and
+ // no included check is impaired or initializing.
+ //
+ // - not-applicable – No checks with Aggregation set to included apply to the
+ // instance.
+ //
+ // - suppressed – Application status reporting is suppressed for the instance.
+ //
+ // Checks with Aggregation set to excluded do not affect this value.
+ Status ApplicationStatusEnum
+
+ // The date and time when the current status started.
+ StatusSince *time.Time
+
+ // The date and time of the last status update.
+ StatusTimeStamp *time.Time
+
+ noSmithyDocumentSerde
+}
+
+// Information about an application status check association. Each item in the
+// associationSet of a DescribeApplicationStatusCheckAssociations response is of
+// this type.
+type ApplicationStatusCheckAssociationObject struct {
+
+ // The ID of the application status check.
+ ApplicationStatusCheckId *string
+
+ // The type of target that the application status check is associated with.
+ // Possible values:
+ //
+ // - tag – The check applies to current and future instances with a matching tag
+ // key-value pair.
+ //
+ // - instance-id – The check applies to a specific instance.
+ AssociationType AssociationTypeEnum
+
+ // The key for the association. This value is present only for tag-based
+ // associations, where it contains the tag key. For instance-based associations,
+ // this value is absent.
+ Key *string
+
+ // The value for the association target. For tag-based associations, this is the
+ // tag value. For instance-based associations, this is the instance ID (for
+ // example, i-0123456789abcdef0 ).
+ Value *string
+
+ noSmithyDocumentSerde
+}
+
+// Describes an application status check.
+type ApplicationStatusCheckResponseObject struct {
+
+ // The aggregation setting for the application status check. When set to included ,
+ // the result of this check contributes to the instance-level application status.
+ // When set to excluded , the check runs independently and does not affect the
+ // instance-level status.
+ Aggregation AggregationStatusEnum
+
+ // The ID of the application status check.
+ ApplicationStatusCheckId *string
+
+ // The date and time when the application status check was created.
+ CreationTime *time.Time
+
+ // The date and time when the application status check was deleted.
+ DeletionTime *time.Time
+
+ // The index of the network device used for the health check. The value is greater
+ // than or equal to 0.
+ DeviceIndex *int32
+
+ // The number of consecutive failed health checks before the application status is
+ // considered impaired. The value must be greater than 0.
+ FailureThreshold *int32
+
+ // The health check paths for the application status check.
+ HealthCheckPaths []HealthCheckPathResponseObject
+
+ // The number of seconds to wait before starting health checks after an instance
+ // is launched. Valid values: 1 to 600.
+ InitializationGracePeriodSeconds *int32
+
+ // The interval, in seconds, between health checks. Valid value: 60.
+ Interval *int32
+
+ // The IP scope used for the health check.
+ IpScope IpScopeEnum
+
+ // The IP version used for the health check.
+ IpVersion IpVersionEnum
+
+ // The date and time when the application status check was last updated.
+ LastUpdatedAt *time.Time
+
+ // The date and time when the application status check was last modified.
+ ModifyTime *time.Time
+
+ // The URL path used for the health check HTTP request.
+ Path *string
+
+ // The port used for the health check.
+ Port *int32
+
+ // The protocol used for the health check.
+ Protocol NetworkProtocolEnum
+
+ // The comma-separated list of individual HTTP status codes or ranges that
+ // indicate a successful health check response.
+ StatusCodeMatcher *string
+
+ // The number of consecutive successful health checks before the application
+ // status is considered healthy. The value must be greater than 0.
+ SuccessThreshold *int32
+
+ // The tags assigned to the application status check.
+ Tags []Tag
+
+ // The [tags] associated with the application status check. Instances with these tags
+ // are automatically monitored by this check.
+ //
+ // [tags]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html
+ TargetTagAssociations []CustomTagKeyValueResponsePair
+
+ // The amount of time, in seconds, to wait for a health check response. Valid
+ // values: 1 to 30.
+ Timeout *int32
+
+ noSmithyDocumentSerde
+}
+
+// Describes the details of an application status check for an instance.
+type ApplicationStatusDetail struct {
+
+ // The aggregation setting for the application status check. When set to included ,
+ // the result of this check contributes to the instance-level application status.
+ // When set to excluded , the check runs independently and does not affect the
+ // instance-level status.
+ Aggregation AggregationStatusEnum
+
+ // The ID of the application status check.
+ ApplicationStatusCheckId *string
+
+ // The date and time when the check was last updated.
+ CheckUpdateTime *time.Time
+
+ // The reason for the current status.
+ Reason *ApplicationStatusReason
+
+ // The status of the individual application status check. Possible values:
+ //
+ // - passed – The check reached its success threshold.
+ //
+ // - failed – The check reached its failure threshold.
+ //
+ // - initializing – The check is initializing or has not reached a success or
+ // failure threshold.
+ //
+ // - insufficient-data – The check does not have enough data to determine a
+ // result.
+ //
+ // - not-applicable – The check does not apply to the instance.
+ //
+ // This value reflects the check result and is not affected by aggregation or
+ // suppression.
+ Status ApplicationStatusCheckEnum
+
+ // The date and time when the current status started for this check.
+ StatusSince *time.Time
+
+ // The date and time of the last status update for this check.
+ StatusTimeStamp *time.Time
+
+ noSmithyDocumentSerde
+}
+
+// Describes the application statuses for instances.
+type ApplicationStatusesResponseType struct {
+
+ // The application status information for the instances.
+ Instances []InstanceApplicationStatus
+
+ noSmithyDocumentSerde
+}
+
+// Describes the reason for an application status check result.
+type ApplicationStatusReason struct {
+
+ // The reason code for the application status check result. Possible values:
+ //
+ // - ResponseCodeMatched – The HTTP status code returned by the health check
+ // matched the configured StatusCodeMatcher .
+ //
+ // - ResponseCodeMismatch – The HTTP status code returned by the health check did
+ // not match the configured StatusCodeMatcher .
+ //
+ // - ConnectionTimeout – The connection to the target timed out.
+ //
+ // - ResponseTimeout – The health check timed out while waiting for a response
+ // from the target.
+ //
+ // - ConnectionRefused – The target refused the health check connection.
+ //
+ // - ConnectionReset – The target reset the health check connection before
+ // returning a response.
+ //
+ // Current health check results use the values in the preceding list. Legacy
+ // results that do not contain structured reason metadata can instead contain a
+ // producer error type, such as Http Status Code or HttpConnectTimeoutException .
+ //
+ // For ResponseCodeMatched and ResponseCodeMismatch , the statusCode field
+ // contains the returned HTTP status code. The protocol field contains the
+ // protocol used for the health check.
+ Code *string
+
+ // The protocol used for the health check. Possible values: HTTP and HTTPS .
+ Protocol *string
+
+ // The HTTP status code returned by the health check.
+ StatusCode *int32
+
+ noSmithyDocumentSerde
+}
+
+// Provides a summary of the application-level health status for an instance.
+type ApplicationStatusSummary struct {
+
+ // The date and time when the application status became impaired.
+ ImpairedSince *time.Time
+
+ // The current status.
+ Status SummaryStatus
+
+ noSmithyDocumentSerde
+}
+
// An Autonomous System Number (ASN) and BYOIP CIDR association.
type AsnAssociation struct {
@@ -3968,6 +4223,31 @@ type CustomerGateway struct {
noSmithyDocumentSerde
}
+// Describes a tag key-value pair for an application status check association
+// request.
+type CustomTagKeyValueRequestPair struct {
+
+ // The key of the tag.
+ Key *string
+
+ // The value of the tag.
+ Value *string
+
+ noSmithyDocumentSerde
+}
+
+// Describes a tag key-value pair for an application status check association.
+type CustomTagKeyValueResponsePair struct {
+
+ // The key of the tag.
+ Key *string
+
+ // The value of the tag.
+ Value *string
+
+ noSmithyDocumentSerde
+}
+
// A query used for retrieving network health data.
type DataQuery struct {
@@ -7351,6 +7631,82 @@ type GroupIdentifier struct {
noSmithyDocumentSerde
}
+// Describes a destination for a health check path in a request. Destinations can
+// be in a different Availability Zone than the source (cross-AZ) or in a Local
+// Zone (AZ to Local Zone), enabling remote health validation of your application.
+type HealthCheckPathDestinationRequestObject struct {
+
+ // The ID of the security group for the destination.
+ SecurityGroupId *string
+
+ // The ID of the subnet for the destination.
+ SubnetId *string
+
+ noSmithyDocumentSerde
+}
+
+// Describes a destination for a health check path.
+type HealthCheckPathDestinationResponseObject struct {
+
+ // The ID of the security group for the destination.
+ SecurityGroupId *string
+
+ // The ID of the subnet for the destination.
+ SubnetId *string
+
+ noSmithyDocumentSerde
+}
+
+// Describes a health check path for an application status check request.
+type HealthCheckPathRequestObject struct {
+
+ // The destinations for the health check path.
+ Destinations []HealthCheckPathDestinationRequestObject
+
+ // The source for the health check path.
+ Source *HealthCheckPathSourceRequestObject
+
+ noSmithyDocumentSerde
+}
+
+// Describes a health check path for an application status check.
+type HealthCheckPathResponseObject struct {
+
+ // The destinations for the health check path.
+ Destinations []HealthCheckPathDestinationResponseObject
+
+ // The source for the health check path.
+ Source *HealthCheckPathSourceResponseObject
+
+ noSmithyDocumentSerde
+}
+
+// Describes the source for a health check path in a request. The source defines
+// the subnet and security group where a health check elastic network interface
+// (ENI) is created to originate health check traffic.
+type HealthCheckPathSourceRequestObject struct {
+
+ // The ID of the security group for the source.
+ SecurityGroupId *string
+
+ // The ID of the subnet for the source.
+ SubnetId *string
+
+ noSmithyDocumentSerde
+}
+
+// Describes the source for a health check path.
+type HealthCheckPathSourceResponseObject struct {
+
+ // The ID of the security group for the source.
+ SecurityGroupId *string
+
+ // The ID of the subnet for the source.
+ SubnetId *string
+
+ noSmithyDocumentSerde
+}
+
// Indicates whether your instance is configured for hibernation. This parameter
// is valid only if the instance meets the [hibernation prerequisites]. For more information, see [Hibernate your Amazon EC2 instance] in the
// Amazon EC2 User Guide.
@@ -8957,6 +9313,27 @@ type Instance struct {
noSmithyDocumentSerde
}
+// Describes the application status for an instance.
+type InstanceApplicationStatus struct {
+
+ // The application status for the instance.
+ ApplicationStatus *ApplicationStatus
+
+ // The Availability Zone of the instance.
+ AvailabilityZone *string
+
+ // The ID of the Availability Zone of the instance.
+ AvailabilityZoneId *string
+
+ // The ID of the instance.
+ InstanceId *string
+
+ // The tags assigned to the instance.
+ Tags []Tag
+
+ noSmithyDocumentSerde
+}
+
// ENA Express uses Amazon Web Services Scalable Reliable Datagram (SRD)
// technology to increase the maximum bandwidth used per stream and minimize tail
// latency of network traffic between EC2 instances. With ENA Express, you can
@@ -10887,9 +11264,14 @@ type InstanceStateChange struct {
noSmithyDocumentSerde
}
-// Describes the status of an instance.
+// Describes the status of an instance, including system status, instance status,
+// attached EBS status, and application status.
type InstanceStatus struct {
+ // Reports impaired functionality that stems from issues with applications running
+ // on the instance.
+ ApplicationStatus *ApplicationStatusSummary
+
// Reports impaired functionality that stems from an attached Amazon EBS volume
// that is unreachable and unable to complete I/O operations.
AttachedEbsStatus *EbsStatusSummary
@@ -22736,6 +23118,22 @@ type Subscription struct {
noSmithyDocumentSerde
}
+// Describes a successful application status check association.
+type SuccessfulAssociationResponseObject struct {
+
+ // The ID of the application status check.
+ ApplicationStatusCheckId *string
+
+ // The type of association. Valid values: EC2TAG and INSTANCE_ID .
+ AssociationType *string
+
+ // The association value. For EC2TAG , the value is formatted as key=value . For
+ // INSTANCE_ID , the value is the instance ID.
+ AssociationValue *string
+
+ noSmithyDocumentSerde
+}
+
// Describes the burstable performance instance whose credit option for CPU usage
// was successfully modified.
type SuccessfulInstanceCreditSpecificationItem struct {
@@ -22755,6 +23153,21 @@ type SuccessfulQueuedPurchaseDeletion struct {
noSmithyDocumentSerde
}
+// Describes a successful application status check suppression.
+type SuccessfulSuppressionResponseObject struct {
+
+ // The ID of the instance.
+ InstanceId *string
+
+ // The date and time when suppression ends and health checks resume.
+ ResumeAt *time.Time
+
+ // The date and time when suppression started.
+ SuppressAt *time.Time
+
+ noSmithyDocumentSerde
+}
+
// Describes a supported Region.
type SupportedRegionDetail struct {
@@ -24515,6 +24928,25 @@ type TunnelOption struct {
noSmithyDocumentSerde
}
+// Describes an unsuccessful application status check association.
+type UnsuccessfulAssociationResponseObject struct {
+
+ // The ID of the application status check.
+ ApplicationStatusCheckId *string
+
+ // The type of association. Valid values: EC2TAG and INSTANCE_ID .
+ AssociationType *string
+
+ // The association value. For EC2TAG , the value is formatted as key=value . For
+ // INSTANCE_ID , the value is the instance ID.
+ AssociationValue *string
+
+ // The reason the association failed.
+ Reason *string
+
+ noSmithyDocumentSerde
+}
+
// Describes the burstable performance instance whose credit option for CPU usage
// was not modified.
type UnsuccessfulInstanceCreditSpecificationItem struct {
@@ -24569,6 +25001,24 @@ type UnsuccessfulItemError struct {
noSmithyDocumentSerde
}
+// Describes an unsuccessful application status check suppression.
+type UnsuccessfulSuppressionResponseObject struct {
+
+ // The ID of the instance.
+ InstanceId *string
+
+ // The reason the suppression failed.
+ Reason *string
+
+ // The date and time when health checks would have resumed.
+ ResumeAt *time.Time
+
+ // The date and time when suppression was attempted.
+ SuppressAt *time.Time
+
+ noSmithyDocumentSerde
+}
+
// Describes the Amazon S3 bucket for the disk image.
type UserBucket struct {
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go
index 81254eb28..0047e5b9e 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ec2/validators.go
@@ -290,6 +290,26 @@ func (m *validateOpAssignPrivateNatGatewayAddress) HandleInitialize(ctx context.
return next.HandleInitialize(ctx, in)
}
+type validateOpAssociateApplicationStatusCheck struct {
+}
+
+func (*validateOpAssociateApplicationStatusCheck) ID() string {
+ return "OperationInputValidation"
+}
+
+func (m *validateOpAssociateApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ input, ok := in.Parameters.(*AssociateApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
+ }
+ if err := validateOpAssociateApplicationStatusCheckInput(input); err != nil {
+ return out, metadata, err
+ }
+ return next.HandleInitialize(ctx, in)
+}
+
type validateOpAssociateCapacityReservationBillingOwner struct {
}
@@ -1150,6 +1170,26 @@ func (m *validateOpCopyVolumes) HandleInitialize(ctx context.Context, in middlew
return next.HandleInitialize(ctx, in)
}
+type validateOpCreateApplicationStatusCheck struct {
+}
+
+func (*validateOpCreateApplicationStatusCheck) ID() string {
+ return "OperationInputValidation"
+}
+
+func (m *validateOpCreateApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ input, ok := in.Parameters.(*CreateApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
+ }
+ if err := validateOpCreateApplicationStatusCheckInput(input); err != nil {
+ return out, metadata, err
+ }
+ return next.HandleInitialize(ctx, in)
+}
+
type validateOpCreateCapacityManagerDataExport struct {
}
@@ -2970,6 +3010,26 @@ func (m *validateOpCreateVpnGateway) HandleInitialize(ctx context.Context, in mi
return next.HandleInitialize(ctx, in)
}
+type validateOpDeleteApplicationStatusCheck struct {
+}
+
+func (*validateOpDeleteApplicationStatusCheck) ID() string {
+ return "OperationInputValidation"
+}
+
+func (m *validateOpDeleteApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ input, ok := in.Parameters.(*DeleteApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
+ }
+ if err := validateOpDeleteApplicationStatusCheckInput(input); err != nil {
+ return out, metadata, err
+ }
+ return next.HandleInitialize(ctx, in)
+}
+
type validateOpDeleteCapacityManagerDataExport struct {
}
@@ -5790,6 +5850,26 @@ func (m *validateOpDisableVpcClassicLink) HandleInitialize(ctx context.Context,
return next.HandleInitialize(ctx, in)
}
+type validateOpDisassociateApplicationStatusCheck struct {
+}
+
+func (*validateOpDisassociateApplicationStatusCheck) ID() string {
+ return "OperationInputValidation"
+}
+
+func (m *validateOpDisassociateApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ input, ok := in.Parameters.(*DisassociateApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
+ }
+ if err := validateOpDisassociateApplicationStatusCheckInput(input); err != nil {
+ return out, metadata, err
+ }
+ return next.HandleInitialize(ctx, in)
+}
+
type validateOpDisassociateCapacityReservationBillingOwner struct {
}
@@ -7830,6 +7910,26 @@ func (m *validateOpModifyAddressAttribute) HandleInitialize(ctx context.Context,
return next.HandleInitialize(ctx, in)
}
+type validateOpModifyApplicationStatusCheck struct {
+}
+
+func (*validateOpModifyApplicationStatusCheck) ID() string {
+ return "OperationInputValidation"
+}
+
+func (m *validateOpModifyApplicationStatusCheck) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
+ out middleware.InitializeOutput, metadata middleware.Metadata, err error,
+) {
+ input, ok := in.Parameters.(*ModifyApplicationStatusCheckInput)
+ if !ok {
+ return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
+ }
+ if err := validateOpModifyApplicationStatusCheckInput(input); err != nil {
+ return out, metadata, err
+ }
+ return next.HandleInitialize(ctx, in)
+}
+
type validateOpModifyAvailabilityZoneGroup struct {
}
@@ -10886,6 +10986,10 @@ func addOpAssignPrivateNatGatewayAddressValidationMiddleware(stack *middleware.S
return stack.Initialize.Add(&validateOpAssignPrivateNatGatewayAddress{}, middleware.After)
}
+func addOpAssociateApplicationStatusCheckValidationMiddleware(stack *middleware.Stack) error {
+ return stack.Initialize.Add(&validateOpAssociateApplicationStatusCheck{}, middleware.After)
+}
+
func addOpAssociateCapacityReservationBillingOwnerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpAssociateCapacityReservationBillingOwner{}, middleware.After)
}
@@ -11058,6 +11162,10 @@ func addOpCopyVolumesValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCopyVolumes{}, middleware.After)
}
+func addOpCreateApplicationStatusCheckValidationMiddleware(stack *middleware.Stack) error {
+ return stack.Initialize.Add(&validateOpCreateApplicationStatusCheck{}, middleware.After)
+}
+
func addOpCreateCapacityManagerDataExportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateCapacityManagerDataExport{}, middleware.After)
}
@@ -11422,6 +11530,10 @@ func addOpCreateVpnGatewayValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpCreateVpnGateway{}, middleware.After)
}
+func addOpDeleteApplicationStatusCheckValidationMiddleware(stack *middleware.Stack) error {
+ return stack.Initialize.Add(&validateOpDeleteApplicationStatusCheck{}, middleware.After)
+}
+
func addOpDeleteCapacityManagerDataExportValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDeleteCapacityManagerDataExport{}, middleware.After)
}
@@ -11986,6 +12098,10 @@ func addOpDisableVpcClassicLinkValidationMiddleware(stack *middleware.Stack) err
return stack.Initialize.Add(&validateOpDisableVpcClassicLink{}, middleware.After)
}
+func addOpDisassociateApplicationStatusCheckValidationMiddleware(stack *middleware.Stack) error {
+ return stack.Initialize.Add(&validateOpDisassociateApplicationStatusCheck{}, middleware.After)
+}
+
func addOpDisassociateCapacityReservationBillingOwnerValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpDisassociateCapacityReservationBillingOwner{}, middleware.After)
}
@@ -12394,6 +12510,10 @@ func addOpModifyAddressAttributeValidationMiddleware(stack *middleware.Stack) er
return stack.Initialize.Add(&validateOpModifyAddressAttribute{}, middleware.After)
}
+func addOpModifyApplicationStatusCheckValidationMiddleware(stack *middleware.Stack) error {
+ return stack.Initialize.Add(&validateOpModifyApplicationStatusCheck{}, middleware.After)
+}
+
func addOpModifyAvailabilityZoneGroupValidationMiddleware(stack *middleware.Stack) error {
return stack.Initialize.Add(&validateOpModifyAvailabilityZoneGroup{}, middleware.After)
}
@@ -14272,6 +14392,21 @@ func validateOpAssignPrivateNatGatewayAddressInput(v *AssignPrivateNatGatewayAdd
}
}
+func validateOpAssociateApplicationStatusCheckInput(v *AssociateApplicationStatusCheckInput) error {
+ if v == nil {
+ return nil
+ }
+ invalidParams := smithy.InvalidParamsError{Context: "AssociateApplicationStatusCheckInput"}
+ if v.ApplicationStatusCheckId == nil {
+ invalidParams.Add(smithy.NewErrParamRequired("ApplicationStatusCheckId"))
+ }
+ if invalidParams.Len() > 0 {
+ return invalidParams
+ } else {
+ return nil
+ }
+}
+
func validateOpAssociateCapacityReservationBillingOwnerInput(v *AssociateCapacityReservationBillingOwnerInput) error {
if v == nil {
return nil
@@ -15016,6 +15151,24 @@ func validateOpCopyVolumesInput(v *CopyVolumesInput) error {
}
}
+func validateOpCreateApplicationStatusCheckInput(v *CreateApplicationStatusCheckInput) error {
+ if v == nil {
+ return nil
+ }
+ invalidParams := smithy.InvalidParamsError{Context: "CreateApplicationStatusCheckInput"}
+ if len(v.Protocol) == 0 {
+ invalidParams.Add(smithy.NewErrParamRequired("Protocol"))
+ }
+ if v.Port == nil {
+ invalidParams.Add(smithy.NewErrParamRequired("Port"))
+ }
+ if invalidParams.Len() > 0 {
+ return invalidParams
+ } else {
+ return nil
+ }
+}
+
func validateOpCreateCapacityManagerDataExportInput(v *CreateCapacityManagerDataExportInput) error {
if v == nil {
return nil
@@ -15984,9 +16137,6 @@ func validateOpCreateSecondaryNetworkInput(v *CreateSecondaryNetworkInput) error
return nil
}
invalidParams := smithy.InvalidParamsError{Context: "CreateSecondaryNetworkInput"}
- if v.Ipv4CidrBlock == nil {
- invalidParams.Add(smithy.NewErrParamRequired("Ipv4CidrBlock"))
- }
if len(v.NetworkType) == 0 {
invalidParams.Add(smithy.NewErrParamRequired("NetworkType"))
}
@@ -16667,6 +16817,21 @@ func validateOpCreateVpnGatewayInput(v *CreateVpnGatewayInput) error {
}
}
+func validateOpDeleteApplicationStatusCheckInput(v *DeleteApplicationStatusCheckInput) error {
+ if v == nil {
+ return nil
+ }
+ invalidParams := smithy.InvalidParamsError{Context: "DeleteApplicationStatusCheckInput"}
+ if v.ApplicationStatusCheckId == nil {
+ invalidParams.Add(smithy.NewErrParamRequired("ApplicationStatusCheckId"))
+ }
+ if invalidParams.Len() > 0 {
+ return invalidParams
+ } else {
+ return nil
+ }
+}
+
func validateOpDeleteCapacityManagerDataExportInput(v *DeleteCapacityManagerDataExportInput) error {
if v == nil {
return nil
@@ -18873,6 +19038,21 @@ func validateOpDisableVpcClassicLinkInput(v *DisableVpcClassicLinkInput) error {
}
}
+func validateOpDisassociateApplicationStatusCheckInput(v *DisassociateApplicationStatusCheckInput) error {
+ if v == nil {
+ return nil
+ }
+ invalidParams := smithy.InvalidParamsError{Context: "DisassociateApplicationStatusCheckInput"}
+ if v.ApplicationStatusCheckId == nil {
+ invalidParams.Add(smithy.NewErrParamRequired("ApplicationStatusCheckId"))
+ }
+ if invalidParams.Len() > 0 {
+ return invalidParams
+ } else {
+ return nil
+ }
+}
+
func validateOpDisassociateCapacityReservationBillingOwnerInput(v *DisassociateCapacityReservationBillingOwnerInput) error {
if v == nil {
return nil
@@ -20575,6 +20755,21 @@ func validateOpModifyAddressAttributeInput(v *ModifyAddressAttributeInput) error
}
}
+func validateOpModifyApplicationStatusCheckInput(v *ModifyApplicationStatusCheckInput) error {
+ if v == nil {
+ return nil
+ }
+ invalidParams := smithy.InvalidParamsError{Context: "ModifyApplicationStatusCheckInput"}
+ if v.ApplicationStatusCheckId == nil {
+ invalidParams.Add(smithy.NewErrParamRequired("ApplicationStatusCheckId"))
+ }
+ if invalidParams.Len() > 0 {
+ return invalidParams
+ } else {
+ return nil
+ }
+}
+
func validateOpModifyAvailabilityZoneGroupInput(v *ModifyAvailabilityZoneGroupInput) error {
if v == nil {
return nil
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/CHANGELOG.md
index 11279e35e..6299f8dd5 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/CHANGELOG.md
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/CHANGELOG.md
@@ -1,3 +1,8 @@
+# v1.90.0 (2026-08-05)
+
+* **Feature**: New enum values added for Agent Connectivity issues
+* **Dependency Update**: Updated to the latest SDK module versions
+
# v1.89.3 (2026-07-31.2)
* **Dependency Update**: Updated to the latest SDK module versions
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/go_module_metadata.go
index 20abc7bce..0af6c7b61 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/go_module_metadata.go
@@ -3,4 +3,4 @@
package ecs
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.89.3"
+const goModuleVersion = "1.90.0"
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/types/enums.go b/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/types/enums.go
index b3ea7ed4b..6fba50300 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/types/enums.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/ecs/types/enums.go
@@ -1231,6 +1231,7 @@ const (
InstanceHealthCheckTypeContainerRuntime InstanceHealthCheckType = "CONTAINER_RUNTIME"
InstanceHealthCheckTypeAcceleratedCompute InstanceHealthCheckType = "ACCELERATED_COMPUTE"
InstanceHealthCheckTypeDaemon InstanceHealthCheckType = "DAEMON"
+ InstanceHealthCheckTypeAgentConnectivity InstanceHealthCheckType = "AGENT_CONNECTIVITY"
)
// Values returns all known values for InstanceHealthCheckType. Note that this can
@@ -1242,6 +1243,7 @@ func (InstanceHealthCheckType) Values() []InstanceHealthCheckType {
"CONTAINER_RUNTIME",
"ACCELERATED_COMPUTE",
"DAEMON",
+ "AGENT_CONNECTIVITY",
}
}
@@ -2193,6 +2195,7 @@ const (
TaskStopCodeServiceSchedulerInitiated TaskStopCode = "ServiceSchedulerInitiated"
TaskStopCodeSpotInterruption TaskStopCode = "SpotInterruption"
TaskStopCodeTerminationNotice TaskStopCode = "TerminationNotice"
+ TaskStopCodeInfrastructureHealth TaskStopCode = "InfrastructureHealth"
)
// Values returns all known values for TaskStopCode. Note that this can be
@@ -2207,6 +2210,7 @@ func (TaskStopCode) Values() []TaskStopCode {
"ServiceSchedulerInitiated",
"SpotInterruption",
"TerminationNotice",
+ "InfrastructureHealth",
}
}
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/iam/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/iam/CHANGELOG.md
index f2e0813b2..b52d17cf3 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/iam/CHANGELOG.md
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/iam/CHANGELOG.md
@@ -1,3 +1,11 @@
+# v1.58.1 (2026-08-05)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
+# v1.58.0 (2026-08-04)
+
+* **Feature**: Updating endpoint generation logic
+
# v1.57.1 (2026-07-31.2)
* **Dependency Update**: Updated to the latest SDK module versions
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/iam/endpoints.go b/vendor/github.com/aws/aws-sdk-go-v2/service/iam/endpoints.go
index d8008bdbd..f28b2dfcf 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/iam/endpoints.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/iam/endpoints.go
@@ -300,8 +300,8 @@ func (p EndpointParameters) WithDefaults() EndpointParameters {
const bddRoot int32 = 2
-var bddNodes = [84]int32{
- -1, 1, -1, 0, 27, 3, 1, 4, 100000024, 2, 5, 100000024, 3, 18, 6, 4, 14, 7, 6, 100000007, 8, 7, 100000009, 9, 9, 100000010, 10, 10, 100000012, 11, 12, 100000014, 12, 13, 100000015, 13, 14, 100000016, 100000023, 5, 100000004, 15, 6, 100000006, 16, 7, 100000008, 17, 8, 100000021, 100000022, 4, 23, 19, 7, 100000009, 20, 9, 100000011, 21, 10, 100000013, 22, 11, 100000019, 100000020, 5, 100000005, 24, 7, 100000008, 25, 8, 26, 100000018, 11, 100000017, 100000018, 3, 100000001, 28, 4, 100000002, 100000003}
+var bddNodes = [129]int32{
+ -1, 1, -1, 0, 42, 3, 1, 4, 100000041, 2, 5, 100000041, 3, 39, 6, 4, 36, 7, 5, 35, 8, 6, 32, 9, 7, 20, 10, 8, 15, 11, 9, 100000018, 12, 10, 100000022, 13, 11, 100000026, 14, 12, 100000030, 100000040, 9, 100000020, 16, 10, 100000024, 17, 11, 100000028, 18, 12, 100000032, 19, 13, 100000038, 100000039, 8, 26, 21, 9, 100000019, 22, 10, 100000023, 23, 11, 100000027, 24, 12, 100000031, 25, 14, 100000036, 100000037, 9, 100000021, 27, 10, 100000025, 28, 11, 100000029, 29, 12, 100000033, 30, 13, 31, 100000035, 14, 100000034, 100000035, 7, 34, 33, 8, 100000016, 100000014, 8, 100000017, 100000015, 8, 100000012, 100000013, 7, 38, 37, 8, 100000008, 100000010, 8, 100000009, 100000011, 7, 41, 40, 8, 100000006, 100000004, 8, 100000007, 100000005, 7, 100000001, 43, 8, 100000002, 100000003}
type conditionContext struct {
PartitionResult *awsrulesfn.PartitionConfig
@@ -320,29 +320,29 @@ func evalCondition(idx int, params *EndpointParameters, c *conditionContext) boo
}
return false
case 3:
- return *params.UseFIPS == true
+ return c.PartitionResult.Name == "aws"
case 4:
- return *params.UseDualStack == true
+ return c.PartitionResult.Name == "aws-cn"
case 5:
- return c.PartitionResult.Name == "aws"
+ return c.PartitionResult.Name == "aws-us-gov"
case 6:
- return c.PartitionResult.Name == "aws-cn"
+ return c.PartitionResult.Name == "aws-iso"
case 7:
- return c.PartitionResult.Name == "aws-us-gov"
+ return *params.UseFIPS == true
case 8:
- return c.PartitionResult.SupportsDualStack == true
+ return *params.UseDualStack == true
case 9:
- return c.PartitionResult.Name == "aws-iso"
- case 10:
return c.PartitionResult.Name == "aws-iso-b"
+ case 10:
+ return c.PartitionResult.Name == "aws-iso-e"
case 11:
- return c.PartitionResult.SupportsFIPS == true
+ return c.PartitionResult.Name == "aws-iso-f"
case 12:
- return c.PartitionResult.Name == "aws-iso-e"
+ return c.PartitionResult.Name == "aws-eusc"
case 13:
- return c.PartitionResult.Name == "aws-iso-f"
+ return c.PartitionResult.SupportsDualStack == true
case 14:
- return c.PartitionResult.Name == "aws-eusc"
+ return c.PartitionResult.SupportsFIPS == true
}
return false
}
@@ -366,7 +366,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
Headers: http.Header{},
}, nil
case 4:
- uriString := "https://iam.global.api.aws"
+ uriString := "https://iam.amazonaws.com"
uri, err := url.Parse(uriString)
if err != nil {
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
@@ -390,7 +390,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
}(),
}, nil
case 5:
- uriString := "https://iam-fips.global.api.aws"
+ uriString := "https://iam-fips.amazonaws.com"
uri, err := url.Parse(uriString)
if err != nil {
return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
@@ -414,6 +414,54 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
}(),
}, nil
case 6:
+ uriString := "https://iam.global.api.aws"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 7:
+ uriString := "https://iam-fips.global.api.aws"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 8:
uriString := "https://iam.global.api.amazonwebservices.com.cn"
uri, err := url.Parse(uriString)
if err != nil {
@@ -437,7 +485,31 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 7:
+ case 9:
+ uriString := "https://iam-fips.api.amazonwebservices.com.cn"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "cn-north-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 10:
uriString := "https://iam.cn-north-1.amazonaws.com.cn"
uri, err := url.Parse(uriString)
if err != nil {
@@ -461,7 +533,31 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 8:
+ case 11:
+ uriString := "https://iam-fips.amazonaws.com.cn"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "cn-north-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 12:
uriString := "https://iam.us-gov.api.aws"
uri, err := url.Parse(uriString)
if err != nil {
@@ -485,7 +581,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 9:
+ case 13:
uriString := "https://iam.us-gov.amazonaws.com"
uri, err := url.Parse(uriString)
if err != nil {
@@ -509,7 +605,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 10:
+ case 14:
uriString := "https://iam.us-iso-east-1.c2s.ic.gov"
uri, err := url.Parse(uriString)
if err != nil {
@@ -533,7 +629,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 11:
+ case 15:
uriString := "https://iam-fips.us-iso-east-1.c2s.ic.gov"
uri, err := url.Parse(uriString)
if err != nil {
@@ -557,7 +653,55 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 12:
+ case 16:
+ uriString := "https://iam.api.aws.ic.gov"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-iso-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 17:
+ uriString := "https://iam-fips.api.aws.ic.gov"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-iso-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 18:
uriString := "https://iam.us-isob-east-1.sc2s.sgov.gov"
uri, err := url.Parse(uriString)
if err != nil {
@@ -581,7 +725,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 13:
+ case 19:
uriString := "https://iam-fips.us-isob-east-1.sc2s.sgov.gov"
uri, err := url.Parse(uriString)
if err != nil {
@@ -605,7 +749,55 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 14:
+ case 20:
+ uriString := "https://iam.api.aws.scloud"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-isob-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 21:
+ uriString := "https://iam-fips.api.aws.scloud"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-isob-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 22:
uriString := "https://iam.eu-isoe-west-1.cloud.adc-e.uk"
uri, err := url.Parse(uriString)
if err != nil {
@@ -629,7 +821,79 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 15:
+ case 23:
+ uriString := "https://iam-fips.cloud.adc-e.uk"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "eu-isoe-west-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 24:
+ uriString := "https://iam.api.cloud-aws.adc-e.uk"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "eu-isoe-west-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 25:
+ uriString := "https://iam-fips.api.cloud-aws.adc-e.uk"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "eu-isoe-west-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 26:
uriString := "https://iam.us-isof-south-1.csp.hci.ic.gov"
uri, err := url.Parse(uriString)
if err != nil {
@@ -653,7 +917,79 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 16:
+ case 27:
+ uriString := "https://iam-fips.csp.hci.ic.gov"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-isof-south-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 28:
+ uriString := "https://iam.api.aws.hci.ic.gov"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-isof-south-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 29:
+ uriString := "https://iam-fips.api.aws.hci.ic.gov"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "us-isof-south-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 30:
uriString := "https://iam.eusc-de-east-1.amazonaws.eu"
uri, err := url.Parse(uriString)
if err != nil {
@@ -677,10 +1013,84 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 17:
+ case 31:
+ uriString := "https://iam-fips.amazonaws.eu"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "eusc-de-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 32:
+ uriString := "https://iam.global.api.amazonwebservices.eu"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "eusc-de-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 33:
+ uriString := "https://iam-fips.api.amazonwebservices.eu"
+ uri, err := url.Parse(uriString)
+ if err != nil {
+ return smithyendpoints.Endpoint{}, fmt.Errorf("Failed to parse uri: %s", uriString)
+ }
+ return smithyendpoints.Endpoint{
+ URI: *uri,
+ Headers: http.Header{},
+ Properties: func() smithy.Properties {
+ var out smithy.Properties
+ smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
+ {
+ SchemeID: "sigv4",
+ SignerProperties: func() smithy.Properties {
+ var sp smithy.Properties
+ smithyhttp.SetSigV4SigningRegion(&sp, "eusc-de-east-1")
+ return sp
+ }(),
+ },
+ })
+ return out
+ }(),
+ }, nil
+ case 34:
uriString := func() string {
var out strings.Builder
out.WriteString("https://iam-fips.")
+ out.WriteString(c.PartitionResult.ImplicitGlobalRegion)
+ out.WriteString(".")
out.WriteString(c.PartitionResult.DualStackDnsSuffix)
return out.String()
}()
@@ -706,12 +1116,14 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 18:
+ case 35:
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS and DualStack are enabled, but this partition does not support one or both")
- case 19:
+ case 36:
uriString := func() string {
var out strings.Builder
out.WriteString("https://iam-fips.")
+ out.WriteString(c.PartitionResult.ImplicitGlobalRegion)
+ out.WriteString(".")
out.WriteString(c.PartitionResult.DnsSuffix)
return out.String()
}()
@@ -737,12 +1149,14 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 20:
+ case 37:
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "FIPS is enabled but this partition does not support FIPS")
- case 21:
+ case 38:
uriString := func() string {
var out strings.Builder
out.WriteString("https://iam.")
+ out.WriteString(c.PartitionResult.ImplicitGlobalRegion)
+ out.WriteString(".")
out.WriteString(c.PartitionResult.DualStackDnsSuffix)
return out.String()
}()
@@ -768,12 +1182,14 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 22:
+ case 39:
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "DualStack is enabled but this partition does not support DualStack")
- case 23:
+ case 40:
uriString := func() string {
var out strings.Builder
out.WriteString("https://iam.")
+ out.WriteString(c.PartitionResult.ImplicitGlobalRegion)
+ out.WriteString(".")
out.WriteString(c.PartitionResult.DnsSuffix)
return out.String()
}()
@@ -799,7 +1215,7 @@ func resolveResult(idx int32, params *EndpointParameters, c *conditionContext) (
return out
}(),
}, nil
- case 24:
+ case 41:
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, %s", "Invalid Configuration: Missing Region")
}
return smithyendpoints.Endpoint{}, fmt.Errorf("endpoint rule error, invalid result index: %d", idx)
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/iam/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/iam/go_module_metadata.go
index b42d47b64..ab8b8d4e7 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/iam/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/iam/go_module_metadata.go
@@ -3,4 +3,4 @@
package iam
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.57.1"
+const goModuleVersion = "1.58.1"
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md
index fb19493e9..e981528e7 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/CHANGELOG.md
@@ -1,3 +1,7 @@
+# v1.13.35 (2026-08-05)
+
+* **Dependency Update**: Updated to the latest SDK module versions
+
# v1.13.34 (2026-07-31.2)
* **Dependency Update**: Updated to the latest SDK module versions
diff --git a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go
index 4568b0152..ed737d188 100644
--- a/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go
+++ b/vendor/github.com/aws/aws-sdk-go-v2/service/internal/presigned-url/go_module_metadata.go
@@ -3,4 +3,4 @@
package presignedurl
// goModuleVersion is the tagged release for this module
-const goModuleVersion = "1.13.34"
+const goModuleVersion = "1.13.35"
diff --git a/vendor/github.com/charmbracelet/ultraviolet/.gitattributes b/vendor/github.com/charmbracelet/ultraviolet/.gitattributes
new file mode 100644
index 000000000..6c929d480
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/.gitattributes
@@ -0,0 +1 @@
+*.golden -text
diff --git a/vendor/github.com/charmbracelet/ultraviolet/.golangci.yml b/vendor/github.com/charmbracelet/ultraviolet/.golangci.yml
new file mode 100644
index 000000000..c90f03161
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/.golangci.yml
@@ -0,0 +1,47 @@
+version: "2"
+run:
+ tests: false
+linters:
+ enable:
+ - bodyclose
+ - exhaustive
+ - goconst
+ - godot
+ - gomoddirectives
+ - goprintffuncname
+ - gosec
+ - misspell
+ - nakedret
+ - nestif
+ - nilerr
+ - noctx
+ - nolintlint
+ - prealloc
+ - revive
+ - rowserrcheck
+ - sqlclosecheck
+ - tparallel
+ - unconvert
+ - unparam
+ - whitespace
+ - wrapcheck
+ exclusions:
+ rules:
+ - text: '(slog|log)\.\w+'
+ linters:
+ - noctx
+ generated: lax
+ presets:
+ - common-false-positives
+ settings:
+ exhaustive:
+ default-signifies-exhaustive: true
+issues:
+ max-issues-per-linter: 0
+ max-same-issues: 0
+formatters:
+ enable:
+ - gofumpt
+ - goimports
+ exclusions:
+ generated: lax
diff --git a/vendor/github.com/charmbracelet/ultraviolet/.goreleaser.yml b/vendor/github.com/charmbracelet/ultraviolet/.goreleaser.yml
new file mode 100644
index 000000000..3353d0202
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/.goreleaser.yml
@@ -0,0 +1,5 @@
+# yaml-language-server: $schema=https://goreleaser.com/static/schema-pro.json
+version: 2
+includes:
+ - from_url:
+ url: charmbracelet/meta/main/goreleaser-lib.yaml
diff --git a/vendor/github.com/muesli/reflow/LICENSE b/vendor/github.com/charmbracelet/ultraviolet/LICENSE
similarity index 96%
rename from vendor/github.com/muesli/reflow/LICENSE
rename to vendor/github.com/charmbracelet/ultraviolet/LICENSE
index 8532c45c9..3217a2fb7 100644
--- a/vendor/github.com/muesli/reflow/LICENSE
+++ b/vendor/github.com/charmbracelet/ultraviolet/LICENSE
@@ -1,6 +1,6 @@
MIT License
-Copyright (c) 2019 Christian Muehlhaeuser
+Copyright (c) 2025 Charmbracelet, Inc
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/vendor/github.com/charmbracelet/ultraviolet/README.md b/vendor/github.com/charmbracelet/ultraviolet/README.md
new file mode 100644
index 000000000..2163601da
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/README.md
@@ -0,0 +1,125 @@
+# Ultraviolet
+
+
+ 
+ 
+
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
diff --git a/vendor/github.com/charmbracelet/ultraviolet/TUTORIAL.md b/vendor/github.com/charmbracelet/ultraviolet/TUTORIAL.md
new file mode 100644
index 000000000..655617213
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/TUTORIAL.md
@@ -0,0 +1,207 @@
+# Hello World!
+
+This is a simple tutorial on how to create a UV application that displays
+"Hello, World!" on the screen. UV is a terminal UI toolkit that allows you to
+create terminal applications with ease. It provides a simple API to handle
+screen management, input handling, and rendering content.
+
+## Tutorial
+
+What does UV consist of? A UV application consists of a screen that displays
+content, has some sort of input sources that can be used to interact with the
+screen, and is meant to display content or programs on the screen.
+
+First, we need to create a screen that will display our program. UV comes with
+a `Terminal` screen that is used to display content on a terminal.
+
+```go
+t := uv.NewTerminal(os.Stdin, os.Stdout, os.Environ())
+// Or simply use...
+// t := uv.DefaultTerminal()
+```
+
+A terminal screen has a few properties that are unique to it. For example, a
+terminal screen can go into raw mode, which is important to disable echoing of
+input characters, and to disable signal handling so that we can receive things
+like ctrl+c without the terminal interfering with our program.
+
+Another important property of a terminal screen is the alternate screen buffer.
+This property puts the terminal screen into a special mode that allows us to
+display content without interfering with the normal screen buffer.
+
+In this tutorial, we will use the alternate screen buffer to display our
+program so that we don't affect the normal screen buffer.
+
+```go
+// Set the terminal to raw mode.
+if err := t.MakeRaw(); err != nil {
+ log.Fatal(err)
+}
+
+// Enter the alternate screen buffer. This will
+// only take affect once we flush or display
+// our program on the terminal screen.
+t.EnterAltScreen()
+
+// My program
+// ...
+
+// Make sure we leave the alternate screen buffer when we
+// are done with our program. This will be called automatically
+// when we use [t.Shutdown(ctx)] later.
+t.LeaveAltScreen()
+
+// Make sure we restore the terminal to its original state
+// before we exit. We don't care about errors here, but you
+// can handle them if you want. This will be called automatically
+// when we use [t.Shutdown(ctx)] later.
+_ = t.Restore() //nolint:errcheck
+```
+
+Now that we have our screen set to raw mode and in the alternate screen buffer,
+we can create our program that will be displayed on the screen. A program is an
+abstraction layer that handles different screen types and implementations. It
+only cares about displaying content on the screen.
+
+We need to start our program before we can display anything on the screen. This
+will ensure that the program and screen are initialized and ready to display
+content. Internally, this will also call `t.Start()` to start the terminal
+screen.
+
+```go
+if err := t.Start(); err != nil {
+ log.Fatalf("failed to start program: %v", err)
+}
+```
+
+Let's display a simple frame with some text in it. A frame is a container that
+holds the buffer we're displaying. The final cursor position we want our cursor
+to be at, and the viewport area we are working with to display our content.
+
+```go
+for i, r := range "Hello, World!" {
+ // We iterate over the string to display each character
+ // in a separate cell. Ideally, we want each cell
+ // to have exactly one grapheme. In this case, since
+ // we're using a simple ASCII string, we know that
+ // each character is a single grapheme with a width of 1.
+ var c uv.Cell
+ c.Content = string(r)
+ c.Width = 1
+ t.SetCell(i, 0, &c)
+}
+// Now we simply render the changes and flush them
+// to the terminal screen.
+_ = p.Display()
+```
+
+Different screen models have different ways to receive input. Some models have
+a remote control, while others have a touch screen. A terminal can receive
+input from various peripherals usually through control codes and escape
+sequences. Our terminal has a `t.Events(ctx)` method that returns a channel
+which will receive events from different terminal input sources.
+
+```go
+// We want to be able to stop the terminal input loop
+// whenever we call cancel().
+ctx, cancel := context.WithCancel(context.Background())
+defer cancel()
+
+for ev := range t.Events(ctx) {
+ switch ev := ev.(type) {
+ case uv.WindowSizeEvent:
+ // Our terminal screen is resizable. This is important
+ // as we want to inform our terminal screen with the
+ // size we'd like to display our program in.
+ // When we're using the full terminal window size,
+ // we can assume that the terminal screen will
+ // also have the same size as our program.
+ // However, with inline programs, usually we want
+ // the height to be the height of our program.
+ // So if our inline program takes 10 lines, we
+ // want to resize the terminal screen to 10 lines
+ // high.
+ width, height := ev.Width, ev.Height
+ if !altscreen {
+ height = 10
+ }
+ t.Resize(width, height)
+ case uv.KeyPressEvent:
+ if ev.MatchStrings("q", "ctrl+c") {
+ // This will stop the input loop and cancel the context.
+ cancel()
+ }
+ }
+}
+```
+
+Now that we've handled displaying our program and receiving input from the
+terminal, we need to handle the program's lifecycle. We need to make sure that
+we restore the terminal to its original state when we exit the program. A
+terminal program can be stopped gracefully using the `t.Shutdown(ctx)` method.
+
+```go
+// We need to make sure we stop the program gracefully
+// after we exit the input loop.
+if err := t.Shutdown(ctx); err != nil {
+ log.Fatal(err)
+}
+```
+
+Finally, let's put everything together and create a simple program that displays
+a frame with "Hello, World!" in it. The program will exit when we press
+ctrl+c or q.
+
+```go
+func main() {
+ t := uv.NewTerminal(os.Stdin, os.Stdout, os.Environ())
+
+ if err := t.MakeRaw(); err != nil {
+ log.Fatalf("failed to make terminal raw: %v", err)
+ }
+
+ if err := t.Start(); err != nil {
+ log.Fatalf("failed to start program: %v", err)
+ }
+
+ t.EnterAltScreen()
+
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ for ev := range t.Events(ctx) {
+ switch ev := ev.(type) {
+ case uv.WindowSizeEvent:
+ width, height := ev.Width, ev.Height
+ t.Erase()
+ t.Resize(width, height)
+ case uv.KeyPressEvent:
+ if ev.MatchStrings("q", "ctrl+c") {
+ cancel()
+ }
+ }
+
+ for i, r := range "Hello, World!" {
+ var c uv.Cell
+ c.Content = string(r)
+ c.Width = 1
+ t.SetCell(i, 0, &c)
+ }
+ if err := t.Display(); err != nil {
+ log.Fatal(err)
+ }
+ }
+
+ if err := t.Shutdown(ctx); err != nil {
+ log.Fatal(err)
+ }
+}
+```
+
+---
+
+Part of [Charm](https://charm.sh).
+
+
+
+Charm热爱开源 • Charm loves open source • نحنُ نحب المصادر المفتوحة
diff --git a/vendor/github.com/charmbracelet/ultraviolet/border.go b/vendor/github.com/charmbracelet/ultraviolet/border.go
new file mode 100644
index 000000000..e24c9a060
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/border.go
@@ -0,0 +1,231 @@
+package uv
+
+// NormalBorder returns a standard-type border with a normal weight and 90
+// degree corners.
+func NormalBorder() Border {
+ return Border{
+ Top: Side{Content: "─"},
+ Bottom: Side{Content: "─"},
+ Left: Side{Content: "│"},
+ Right: Side{Content: "│"},
+ TopLeft: Side{Content: "┌"},
+ TopRight: Side{Content: "┐"},
+ BottomLeft: Side{Content: "└"},
+ BottomRight: Side{Content: "┘"},
+ }
+}
+
+// RoundedBorder returns a border with rounded corners.
+func RoundedBorder() Border {
+ return Border{
+ Top: Side{Content: "─"},
+ Bottom: Side{Content: "─"},
+ Left: Side{Content: "│"},
+ Right: Side{Content: "│"},
+ TopLeft: Side{Content: "╭"},
+ TopRight: Side{Content: "╮"},
+ BottomLeft: Side{Content: "╰"},
+ BottomRight: Side{Content: "╯"},
+ }
+}
+
+// BlockBorder returns a border that takes the whole block.
+func BlockBorder() Border {
+ return Border{
+ Top: Side{Content: "█"},
+ Bottom: Side{Content: "█"},
+ Left: Side{Content: "█"},
+ Right: Side{Content: "█"},
+ TopLeft: Side{Content: "█"},
+ TopRight: Side{Content: "█"},
+ BottomLeft: Side{Content: "█"},
+ BottomRight: Side{Content: "█"},
+ }
+}
+
+// OuterHalfBlockBorder returns a half-block border that sits outside the frame.
+func OuterHalfBlockBorder() Border {
+ return Border{
+ Top: Side{Content: "▀"},
+ Bottom: Side{Content: "▄"},
+ Left: Side{Content: "▌"},
+ Right: Side{Content: "▐"},
+ TopLeft: Side{Content: "▛"},
+ TopRight: Side{Content: "▜"},
+ BottomLeft: Side{Content: "▙"},
+ BottomRight: Side{Content: "▟"},
+ }
+}
+
+// InnerHalfBlockBorder returns a half-block border that sits inside the frame.
+func InnerHalfBlockBorder() Border {
+ return Border{
+ Top: Side{Content: "▄"},
+ Bottom: Side{Content: "▀"},
+ Left: Side{Content: "▐"},
+ Right: Side{Content: "▌"},
+ TopLeft: Side{Content: "▗"},
+ TopRight: Side{Content: "▖"},
+ BottomLeft: Side{Content: "▝"},
+ BottomRight: Side{Content: "▘"},
+ }
+}
+
+// ThickBorder returns a border that's thicker than the one returned by
+// NormalBorder.
+func ThickBorder() Border {
+ return Border{
+ Top: Side{Content: "━"},
+ Bottom: Side{Content: "━"},
+ Left: Side{Content: "┃"},
+ Right: Side{Content: "┃"},
+ TopLeft: Side{Content: "┏"},
+ TopRight: Side{Content: "┓"},
+ BottomLeft: Side{Content: "┗"},
+ BottomRight: Side{Content: "┛"},
+ }
+}
+
+// DoubleBorder returns a border comprised of two thin strokes.
+func DoubleBorder() Border {
+ return Border{
+ Top: Side{Content: "═"},
+ Bottom: Side{Content: "═"},
+ Left: Side{Content: "║"},
+ Right: Side{Content: "║"},
+ TopLeft: Side{Content: "╔"},
+ TopRight: Side{Content: "╗"},
+ BottomLeft: Side{Content: "╚"},
+ BottomRight: Side{Content: "╝"},
+ }
+}
+
+// HiddenBorder returns a border that renders as a series of single-cell
+// spaces. It's useful for cases when you want to remove a standard border but
+// maintain layout positioning. This said, you can still apply a background
+// color to a hidden border.
+func HiddenBorder() Border {
+ return Border{
+ Top: Side{Content: " "},
+ Bottom: Side{Content: " "},
+ Left: Side{Content: " "},
+ Right: Side{Content: " "},
+ TopLeft: Side{Content: " "},
+ TopRight: Side{Content: " "},
+ BottomLeft: Side{Content: " "},
+ BottomRight: Side{Content: " "},
+ }
+}
+
+// MarkdownBorder return a table border in markdown style.
+func MarkdownBorder() Border {
+ return Border{
+ Left: Side{Content: "|"},
+ Right: Side{Content: "|"},
+ TopLeft: Side{Content: "|"},
+ TopRight: Side{Content: "|"},
+ BottomLeft: Side{Content: "|"},
+ BottomRight: Side{Content: "|"},
+ }
+}
+
+// ASCIIBorder returns a table border with ASCII characters.
+func ASCIIBorder() Border {
+ return Border{
+ Top: Side{Content: "-"},
+ Bottom: Side{Content: "-"},
+ Left: Side{Content: "|"},
+ Right: Side{Content: "|"},
+ TopLeft: Side{Content: "+"},
+ TopRight: Side{Content: "+"},
+ BottomLeft: Side{Content: "+"},
+ BottomRight: Side{Content: "+"},
+ }
+}
+
+// Side represents a single border side with its properties.
+type Side struct {
+ Content string
+ Style
+ Link
+}
+
+// Border represents a border with its properties.
+type Border struct {
+ Top Side
+ Bottom Side
+ Left Side
+ Right Side
+ TopLeft Side
+ TopRight Side
+ BottomLeft Side
+ BottomRight Side
+}
+
+// Style returns a new [Border] with the given style applied to all [Side]s.
+func (b Border) Style(style Style) Border {
+ b.Top.Style = style
+ b.Bottom.Style = style
+ b.Left.Style = style
+ b.Right.Style = style
+ b.TopLeft.Style = style
+ b.TopRight.Style = style
+ b.BottomLeft.Style = style
+ b.BottomRight.Style = style
+ return b
+}
+
+// Link returns a new [Border] with the given link applied to all [Side]s.
+func (b Border) Link(link Link) Border {
+ b.Top.Link = link
+ b.Bottom.Link = link
+ b.Left.Link = link
+ b.Right.Link = link
+ b.TopLeft.Link = link
+ b.TopRight.Link = link
+ b.BottomLeft.Link = link
+ b.BottomRight.Link = link
+ return b
+}
+
+// Draw draws the border around the given component.
+func (b *Border) Draw(scr Screen, area Rectangle) {
+ for y := area.Min.Y; y < area.Max.Y; y++ {
+ for x := area.Min.X; x < area.Max.X; x++ {
+ var cell *Cell
+ switch {
+ case y == area.Min.Y && x == area.Min.X:
+ cell = borderCell(scr, &b.TopLeft)
+ case y == area.Min.Y && x == area.Max.X-1:
+ cell = borderCell(scr, &b.TopRight)
+ case y == area.Max.Y-1 && x == area.Min.X:
+ cell = borderCell(scr, &b.BottomLeft)
+ case y == area.Max.Y-1 && x == area.Max.X-1:
+ cell = borderCell(scr, &b.BottomRight)
+ case y == area.Min.Y:
+ cell = borderCell(scr, &b.Top)
+ case y == area.Max.Y-1:
+ cell = borderCell(scr, &b.Bottom)
+ case x == area.Min.X:
+ cell = borderCell(scr, &b.Left)
+ case x == area.Max.X-1:
+ cell = borderCell(scr, &b.Right)
+ default:
+ continue
+ }
+ if cell == nil {
+ continue
+ }
+ scr.SetCell(x, y, cell)
+ }
+ }
+}
+
+func borderCell(scr Screen, b *Side) *Cell {
+ c := NewCell(scr.WidthMethod(), b.Content)
+ if c != nil {
+ c.Style = b.Style
+ c.Link = b.Link
+ }
+ return c
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/buffer.go b/vendor/github.com/charmbracelet/ultraviolet/buffer.go
new file mode 100644
index 000000000..f88164d88
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/buffer.go
@@ -0,0 +1,795 @@
+package uv
+
+import (
+ "bytes"
+ "image"
+ "io"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Position represents a position in a coordinate system.
+type Position = image.Point
+
+// Pos is a shorthand for creating a new [Position].
+func Pos(x, y int) Position {
+ return Position{X: x, Y: y}
+}
+
+// Rectangle represents a rectangular area.
+type Rectangle = image.Rectangle
+
+// Rect is a shorthand for creating a new [Rectangle].
+func Rect(x, y, w, h int) Rectangle {
+ return Rectangle{Min: image.Point{X: x, Y: y}, Max: image.Point{X: x + w, Y: y + h}}
+}
+
+// Line represents cells in a line.
+type Line []Cell
+
+// NewLine creates a new line with the given width, filled with empty cells.
+func NewLine(width int) Line {
+ l := make(Line, width)
+ for i := range l {
+ l[i] = EmptyCell
+ }
+ return l
+}
+
+// Set sets the cell at the given x position.
+func (l Line) Set(x int, c *Cell) {
+ lineWidth := len(l)
+ if x < 0 || x >= lineWidth {
+ return
+ }
+
+ // When a wide cell is partially overwritten, we need
+ // to fill the rest of the cell with space cells to
+ // avoid rendering issues.
+ var prev *Cell
+ if prev = l.At(x); prev != nil { //nolint:nestif
+ if pw := prev.Width; pw > 1 {
+ // Writing to the first wide cell
+ for j := 0; j < pw && x+j < lineWidth; j++ {
+ l[x+j] = *prev
+ l[x+j].Empty()
+ }
+ } else if pw == 0 {
+ // Writing to wide cell placeholders
+ for j := 1; x-j >= 0; j++ {
+ if wide := l.At(x - j); wide != nil {
+ if ww := wide.Width; ww > 1 && j < ww {
+ for k := range ww {
+ l[x-j+k] = *wide
+ l[x-j+k].Empty()
+ }
+ break
+ }
+ }
+ }
+ }
+ }
+
+ if c == nil {
+ // Nil cells are treated as blank empty cells.
+ l[x] = EmptyCell
+ return
+ }
+
+ l[x] = *c
+ cw := c.Width
+ if x+cw > lineWidth {
+ // If the cell is too wide, we write blanks with the same style.
+ for i := 0; i < cw && x+i < lineWidth; i++ {
+ l[x+i] = *c
+ l[x+i].Empty()
+ }
+ return
+ }
+
+ if cw > 1 {
+ // Mark wide cells with an zero cells.
+ // We set the wide cell down below
+ for j := 1; j < cw && x+j < lineWidth; j++ {
+ l[x+j] = Cell{}
+ }
+ }
+}
+
+// At returns the cell at the given x position.
+// If the cell does not exist, it returns nil.
+func (l Line) At(x int) *Cell {
+ if x < 0 || x >= len(l) {
+ return nil
+ }
+
+ return &l[x]
+}
+
+// String returns the string representation of the line. Any trailing spaces
+// are removed.
+func (l Line) String() string {
+ var buf strings.Builder
+ var pending bytes.Buffer
+ for _, c := range l {
+ if c.IsZero() {
+ continue
+ }
+ if c.Equal(&EmptyCell) {
+ pending.WriteByte(' ')
+ continue
+ }
+ if pending.Len() > 0 {
+ buf.WriteString(pending.String())
+ pending.Reset()
+ }
+ buf.WriteString(c.String())
+ }
+
+ return buf.String()
+}
+
+// Render renders the line to a string with all the required attributes and
+// styles.
+func (l Line) Render() string {
+ var buf strings.Builder
+ renderLine(&buf, l)
+ return buf.String()
+}
+
+func renderLine(buf io.StringWriter, l Line) {
+ var pen Style
+ var link Link
+ var pending bytes.Buffer
+
+ for _, c := range l {
+ if c.IsZero() {
+ continue
+ }
+ if c.Equal(&EmptyCell) {
+ if !pen.IsZero() {
+ _, _ = buf.WriteString(ansi.ResetStyle)
+ pen = Style{}
+ }
+ if !link.IsZero() {
+ _, _ = buf.WriteString(ansi.ResetHyperlink())
+ link = Link{}
+ }
+ pending.WriteByte(' ')
+ continue
+ }
+
+ if pending.Len() > 0 {
+ _, _ = buf.WriteString(pending.String())
+ pending.Reset()
+ }
+
+ if c.Style.IsZero() && !pen.IsZero() {
+ _, _ = buf.WriteString(ansi.ResetStyle)
+ pen = Style{}
+ }
+ if !c.Style.Equal(&pen) {
+ seq := c.Style.Diff(&pen)
+ _, _ = buf.WriteString(seq)
+ pen = c.Style
+ }
+
+ // Write the URL escape sequence
+ if c.Link != link && link.URL != "" {
+ _, _ = buf.WriteString(ansi.ResetHyperlink())
+ link = Link{}
+ }
+ if c.Link != link {
+ _, _ = buf.WriteString(ansi.SetHyperlink(c.Link.URL, c.Link.Params))
+ link = c.Link
+ }
+
+ _, _ = buf.WriteString(c.String())
+ }
+
+ if link.URL != "" {
+ _, _ = buf.WriteString(ansi.ResetHyperlink())
+ }
+ if !pen.IsZero() {
+ _, _ = buf.WriteString(ansi.ResetStyle)
+ }
+}
+
+// Lines represents a slice of lines.
+type Lines []Line
+
+// Height returns the height of the lines.
+func (ls Lines) Height() int {
+ return len(ls)
+}
+
+// Width returns the width of the widest line.
+func (ls Lines) Width() int {
+ maxWidth := 0
+ for _, l := range ls {
+ maxWidth = max(maxWidth, len(l))
+ }
+ return maxWidth
+}
+
+// String returns the string representation of the lines.
+func (ls Lines) String() string {
+ var buf strings.Builder
+ for i, l := range ls {
+ buf.WriteString(l.String())
+ if i < len(ls)-1 {
+ _ = buf.WriteByte('\n')
+ }
+ }
+ return buf.String()
+}
+
+// Render renders the lines to a styled string with all the required attributes
+// and styles.
+func (ls Lines) Render() string {
+ var buf strings.Builder
+ for i, l := range ls {
+ renderLine(&buf, l)
+ if i < len(ls)-1 {
+ _ = buf.WriteByte('\n')
+ }
+ }
+ return buf.String()
+}
+
+// Buffer represents a cell buffer that contains the contents of a screen.
+type Buffer struct {
+ // Lines is a slice of lines that make up the cells of the buffer.
+ Lines []Line
+}
+
+var _ Drawable = (*Buffer)(nil)
+
+// NewBuffer creates a new buffer with the given width and height.
+// This is a convenience function that initializes a new buffer and resizes it.
+func NewBuffer(width int, height int) *Buffer {
+ b := new(Buffer)
+ b.Lines = make([]Line, height)
+ for i := range b.Lines {
+ b.Lines[i] = make(Line, width)
+ for j := range b.Lines[i] {
+ b.Lines[i][j] = EmptyCell
+ }
+ }
+ b.Resize(width, height)
+ return b
+}
+
+// String returns the string representation of the buffer.
+func (b *Buffer) String() string {
+ return Lines(b.Lines).String()
+}
+
+// Render renders the buffer to a styled string with all the required
+// attributes and styles.
+func (b *Buffer) Render() string {
+ return Lines(b.Lines).Render()
+}
+
+// Line returns a pointer to the line at the given y position.
+// If the line does not exist, it returns nil.
+func (b *Buffer) Line(y int) Line {
+ if y < 0 || y >= len(b.Lines) {
+ return nil
+ }
+ return b.Lines[y]
+}
+
+// CellAt returns the cell at the given position. It returns nil if the
+// position is out of bounds.
+func (b *Buffer) CellAt(x int, y int) *Cell {
+ if y < 0 || y >= len(b.Lines) {
+ return nil
+ }
+ return b.Lines[y].At(x)
+}
+
+// SetCell sets the cell at the given x, y position.
+func (b *Buffer) SetCell(x, y int, c *Cell) {
+ if y < 0 || y >= len(b.Lines) {
+ return
+ }
+
+ b.Lines[y].Set(x, c)
+}
+
+// Height implements Screen.
+func (b *Buffer) Height() int {
+ return len(b.Lines)
+}
+
+// Width implements Screen.
+func (b *Buffer) Width() int {
+ if len(b.Lines) == 0 {
+ return 0
+ }
+ return len(b.Lines[0])
+}
+
+// Bounds returns the bounds of the buffer.
+// The origin is always at (0, 0) and the maximum coordinates are determined by
+// the width and height of the buffer.
+func (b *Buffer) Bounds() Rectangle {
+ return Rect(0, 0, b.Width(), b.Height())
+}
+
+// Resize resizes the buffer to the given width and height.
+func (b *Buffer) Resize(width int, height int) {
+ curWidth, curHeight := b.Width(), b.Height()
+ if curWidth == width && curHeight == height {
+ // No need to resize if the dimensions are the same.
+ return
+ }
+
+ if width > curWidth {
+ line := make(Line, width-curWidth)
+ for i := range line {
+ line[i] = EmptyCell
+ }
+ for i := range b.Lines {
+ b.Lines[i] = append(b.Lines[i], line...)
+ }
+ } else if width < curWidth {
+ for i := range b.Lines {
+ b.Lines[i] = b.Lines[i][:width]
+ }
+ }
+
+ if height > len(b.Lines) {
+ for i := len(b.Lines); i < height; i++ {
+ line := make(Line, width)
+ for j := range line {
+ line[j] = EmptyCell
+ }
+ b.Lines = append(b.Lines, line)
+ }
+ } else if height < len(b.Lines) {
+ b.Lines = b.Lines[:height]
+ }
+}
+
+// Fill fills the buffer with the given cell and rectangle.
+func (b *Buffer) Fill(c *Cell) {
+ b.FillArea(c, b.Bounds())
+}
+
+// FillArea fills the buffer with the given cell and rectangle.
+func (b *Buffer) FillArea(c *Cell, area Rectangle) {
+ cellWidth := 1
+ if c != nil && c.Width > 1 {
+ cellWidth = c.Width
+ }
+ for y := area.Min.Y; y < area.Max.Y; y++ {
+ for x := area.Min.X; x < area.Max.X; x += cellWidth {
+ b.SetCell(x, y, c)
+ }
+ }
+}
+
+// Clear clears the buffer with space cells and rectangle.
+func (b *Buffer) Clear() {
+ area := b.Bounds()
+ for y := area.Min.Y; y < area.Max.Y; y++ {
+ for x := area.Min.X; x < area.Max.X; x++ {
+ b.Lines[y][x] = EmptyCell
+ }
+ }
+}
+
+// ClearArea clears the buffer with space cells within the specified
+// rectangles. Only cells within the rectangle's bounds are affected.
+func (b *Buffer) ClearArea(area Rectangle) {
+ b.FillArea(nil, area)
+}
+
+// CloneArea clones the area of the buffer within the specified rectangle. If
+// the area is out of bounds, it returns nil.
+func (b *Buffer) CloneArea(area Rectangle) *Buffer {
+ bounds := b.Bounds()
+ if !area.In(bounds) {
+ return nil
+ }
+ n := NewBuffer(area.Dx(), area.Dy())
+ for y := area.Min.Y; y < area.Max.Y; y++ {
+ for x := area.Min.X; x < area.Max.X; {
+ c := b.CellAt(x, y)
+ if c == nil || c.IsZero() {
+ x++
+ continue
+ }
+ n.SetCell(x-area.Min.X, y-area.Min.Y, c)
+ x += max(c.Width, 1)
+ }
+ }
+ return n
+}
+
+// Clone clones the entire buffer into a new buffer.
+func (b *Buffer) Clone() *Buffer {
+ return b.CloneArea(b.Bounds())
+}
+
+// Draw draws the buffer to the given screen at the specified area.
+// It implements the [Drawable] interface.
+func (b *Buffer) Draw(scr Screen, area Rectangle) {
+ if area.Empty() {
+ return
+ }
+
+ // Ensure the area is within the bounds of the screen.
+ bounds := scr.Bounds()
+ if !area.Overlaps(bounds) {
+ return
+ }
+
+ for y := area.Min.Y; y < area.Max.Y; y++ {
+ for x := area.Min.X; x < area.Max.X; {
+ c := b.CellAt(x-area.Min.X, y-area.Min.Y)
+ if c == nil || c.IsZero() {
+ x++
+ continue
+ }
+ scr.SetCell(x, y, c)
+ width := c.Width
+ if width <= 0 {
+ width = 1
+ }
+ x += width
+ }
+ }
+}
+
+// InsertLine inserts n lines at the given line position, with the given
+// optional cell, within the specified rectangles. If no rectangles are
+// specified, it inserts lines in the entire buffer. Only cells within the
+// rectangle's horizontal bounds are affected. Lines are pushed out of the
+// rectangle bounds and lost. This follows terminal [ansi.IL] behavior.
+// It returns the pushed out lines.
+func (b *Buffer) InsertLine(y, n int, c *Cell) {
+ b.InsertLineArea(y, n, c, b.Bounds())
+}
+
+// InsertLineArea inserts new lines at the given line position, with the
+// given optional cell, within the rectangle bounds. Only cells within the
+// rectangle's horizontal bounds are affected. Lines are pushed out of the
+// rectangle bounds and lost. This follows terminal [ansi.IL] behavior.
+func (b *Buffer) InsertLineArea(y, n int, c *Cell, area Rectangle) {
+ if n <= 0 || y < area.Min.Y || y >= area.Max.Y || y >= b.Height() {
+ return
+ }
+
+ // Limit number of lines to insert to available space
+ if y+n > area.Max.Y {
+ n = area.Max.Y - y
+ }
+
+ // Move existing lines down within the bounds
+ for i := area.Max.Y - 1; i >= y+n; i-- {
+ for x := area.Min.X; x < area.Max.X; x++ {
+ // We don't need to clone c here because we're just moving lines down.
+ b.Lines[i][x] = b.Lines[i-n][x]
+ }
+ }
+
+ // Clear the newly inserted lines within bounds
+ for i := y; i < y+n; i++ {
+ for x := area.Min.X; x < area.Max.X; x++ {
+ b.SetCell(x, i, c)
+ }
+ }
+}
+
+// DeleteLineArea deletes lines at the given line position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's bounds are affected. Lines are shifted up within the bounds and
+// new blank lines are created at the bottom. This follows terminal [ansi.DL]
+// behavior.
+func (b *Buffer) DeleteLineArea(y, n int, c *Cell, area Rectangle) {
+ if n <= 0 || y < area.Min.Y || y >= area.Max.Y || y >= b.Height() {
+ return
+ }
+
+ // Limit deletion count to available space in scroll region
+ if n > area.Max.Y-y {
+ n = area.Max.Y - y
+ }
+
+ // Shift cells up within the bounds
+ for dst := y; dst < area.Max.Y-n; dst++ {
+ src := dst + n
+ for x := area.Min.X; x < area.Max.X; x++ {
+ // We don't need to clone c here because we're just moving cells up.
+ b.Lines[dst][x] = b.Lines[src][x]
+ }
+ }
+
+ // Fill the bottom n lines with blank cells
+ for i := area.Max.Y - n; i < area.Max.Y; i++ {
+ for x := area.Min.X; x < area.Max.X; x++ {
+ b.SetCell(x, i, c)
+ }
+ }
+}
+
+// DeleteLine deletes n lines at the given line position, with the given
+// optional cell, within the specified rectangles. If no rectangles are
+// specified, it deletes lines in the entire buffer.
+func (b *Buffer) DeleteLine(y, n int, c *Cell) {
+ b.DeleteLineArea(y, n, c, b.Bounds())
+}
+
+// InsertCell inserts new cells at the given position, with the given optional
+// cell, within the specified rectangles. If no rectangles are specified, it
+// inserts cells in the entire buffer. This follows terminal [ansi.ICH]
+// behavior.
+func (b *Buffer) InsertCell(x, y, n int, c *Cell) {
+ b.InsertCellArea(x, y, n, c, b.Bounds())
+}
+
+// InsertCellArea inserts new cells at the given position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's bounds are affected, following terminal [ansi.ICH] behavior.
+func (b *Buffer) InsertCellArea(x, y, n int, c *Cell, area Rectangle) {
+ if n <= 0 || y < area.Min.Y || y >= area.Max.Y || y >= b.Height() ||
+ x < area.Min.X || x >= area.Max.X || x >= b.Width() {
+ return
+ }
+
+ // Limit number of cells to insert to available space
+ if x+n > area.Max.X {
+ n = area.Max.X - x
+ }
+
+ // Move existing cells within rectangle bounds to the right
+ for i := area.Max.X - 1; i >= x+n && i-n >= area.Min.X; i-- {
+ // We don't need to clone c here because we're just moving cells to the
+ // right.
+ b.Lines[y][i] = b.Lines[y][i-n]
+ }
+
+ // Clear the newly inserted cells within rectangle bounds
+ for i := x; i < x+n && i < area.Max.X; i++ {
+ b.SetCell(i, y, c)
+ }
+}
+
+// DeleteCell deletes cells at the given position, with the given optional
+// cell, within the specified rectangles. If no rectangles are specified, it
+// deletes cells in the entire buffer. This follows terminal [ansi.DCH]
+// behavior.
+func (b *Buffer) DeleteCell(x, y, n int, c *Cell) {
+ b.DeleteCellArea(x, y, n, c, b.Bounds())
+}
+
+// DeleteCellArea deletes cells at the given position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's bounds are affected, following terminal [ansi.DCH] behavior.
+func (b *Buffer) DeleteCellArea(x, y, n int, c *Cell, area Rectangle) {
+ if n <= 0 || y < area.Min.Y || y >= area.Max.Y || y >= b.Height() ||
+ x < area.Min.X || x >= area.Max.X || x >= b.Width() {
+ return
+ }
+
+ // Calculate how many positions we can actually delete
+ remainingCells := area.Max.X - x
+ if n > remainingCells {
+ n = remainingCells
+ }
+
+ // Shift the remaining cells to the left
+ for i := x; i < area.Max.X-n; i++ {
+ if i+n < area.Max.X {
+ // We need to use SetCell here to ensure we blank out any wide
+ // cells we encounter.
+ b.SetCell(i, y, b.CellAt(i+n, y))
+ }
+ }
+
+ // Fill the vacated positions with the given cell
+ for i := area.Max.X - n; i < area.Max.X; i++ {
+ b.SetCell(i, y, c)
+ }
+}
+
+// ScreenBuffer is a buffer that can be used as a [Screen].
+type ScreenBuffer struct {
+ *RenderBuffer
+ Method ansi.Method
+}
+
+var (
+ _ Screen = ScreenBuffer{}
+ _ Drawable = ScreenBuffer{}
+)
+
+// NewScreenBuffer creates a new ScreenBuffer with the given width and height.
+func NewScreenBuffer(width, height int) ScreenBuffer {
+ return ScreenBuffer{
+ RenderBuffer: NewRenderBuffer(width, height),
+ Method: ansi.WcWidth,
+ }
+}
+
+// WidthMethod returns the width method used by the screen.
+// It defaults to [ansi.WcWidth].
+func (s ScreenBuffer) WidthMethod() WidthMethod {
+ return s.Method
+}
+
+// TrimSpace trims trailing spaces from the end of each line in the given
+// string.
+func TrimSpace(s string) string {
+ lines := strings.Split(s, "\n")
+ for i, line := range lines {
+ // Check if we have a trailing '\r' and preserve it
+ hasCR := strings.HasSuffix(line, "\r")
+ if hasCR {
+ line = strings.TrimSuffix(line, "\r")
+ }
+ line = strings.TrimRight(line, " ")
+ if hasCR {
+ line = line + "\r"
+ }
+ lines[i] = line
+ }
+ return strings.Join(lines, "\n")
+}
+
+// RenderBuffer represents a buffer that keeps track of the current and new
+// state of the screen, allowing for efficient rendering by only updating the
+// parts of the screen that have changed.
+type RenderBuffer struct {
+ *Buffer
+ Touched []*LineData
+}
+
+// NewRenderBuffer creates a new [RenderBuffer] with the given width and height.
+func NewRenderBuffer(width, height int) *RenderBuffer {
+ return &RenderBuffer{
+ Buffer: NewBuffer(width, height),
+ Touched: make([]*LineData, height),
+ }
+}
+
+// TouchLine marks a line n times starting at the given x position as touched.
+func (b *RenderBuffer) TouchLine(x, y, n int) {
+ if y < 0 || y >= len(b.Lines) {
+ return
+ }
+
+ if y >= len(b.Touched) {
+ b.Touched = append(b.Touched, make([]*LineData, y-len(b.Touched)+1)...)
+ }
+
+ // Re-check bounds: a concurrent resize may have cleared Touched
+ if y >= len(b.Touched) {
+ return
+ }
+
+ ch := b.Touched[y]
+ if ch == nil {
+ ch = &LineData{FirstCell: x, LastCell: x + n}
+ } else {
+ ch.FirstCell = min(ch.FirstCell, x)
+ ch.LastCell = max(ch.LastCell, x+n)
+ }
+ b.Touched[y] = ch
+}
+
+// Touch marks the cell at the given x, y position as touched.
+func (b *RenderBuffer) Touch(x, y int) {
+ b.TouchLine(x, y, 0)
+}
+
+// TouchedLines returns the number of touched lines in the buffer.
+func (b *RenderBuffer) TouchedLines() int {
+ if b.Touched == nil {
+ return 0
+ }
+ count := 0
+ for _, t := range b.Touched {
+ if t != nil {
+ count++
+ }
+ }
+ return count
+}
+
+// SetCell sets the cell at the given x, y position and marks the line as
+// touched.
+func (b *RenderBuffer) SetCell(x, y int, c *Cell) {
+ if !cellEqual(b.CellAt(x, y), c) {
+ width := 1
+ if c != nil && c.Width > 0 {
+ width = c.Width
+ }
+ b.TouchLine(x, y, width)
+ }
+ b.Buffer.SetCell(x, y, c)
+}
+
+// InsertLine inserts n lines at the given line position, with the given
+// optional cell, within the specified rectangles. If no rectangles are
+// specified, it inserts lines in the entire buffer. Only cells within the
+// rectangle's horizontal bounds are affected. Lines are pushed out of the
+// rectangle bounds and lost. This follows terminal [ansi.IL] behavior.
+func (b *RenderBuffer) InsertLine(y, n int, c *Cell) {
+ b.InsertLineArea(y, n, c, b.Bounds())
+}
+
+// InsertLineArea inserts new lines at the given line position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's horizontal bounds are affected. Lines are pushed out of the
+// rectangle bounds and lost. This follows terminal [ansi.IL] behavior.
+func (b *RenderBuffer) InsertLineArea(y, n int, c *Cell, area Rectangle) {
+ b.Buffer.InsertLineArea(y, n, c, area)
+ for i := area.Min.Y; i < area.Max.Y; i++ {
+ b.TouchLine(area.Min.X, i, area.Max.X-area.Min.X)
+ b.TouchLine(area.Min.X, i-n, area.Max.X-area.Min.X)
+ }
+}
+
+// DeleteLine deletes n lines at the given line position, with the given
+// optional cell, within the specified rectangles. If no rectangles are
+// specified, it deletes lines in the entire buffer.
+func (b *RenderBuffer) DeleteLine(y, n int, c *Cell) {
+ b.DeleteLineArea(y, n, c, b.Bounds())
+}
+
+// DeleteLineArea deletes lines at the given line position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's bounds are affected. Lines are shifted up within the bounds and
+// new blank lines are created at the bottom. This follows terminal [ansi.DL]
+// behavior.
+func (b *RenderBuffer) DeleteLineArea(y, n int, c *Cell, area Rectangle) {
+ b.Buffer.DeleteLineArea(y, n, c, area)
+ for i := area.Min.Y; i < area.Max.Y; i++ {
+ b.TouchLine(area.Min.X, i, area.Max.X-area.Min.X)
+ b.TouchLine(area.Min.X, i+n, area.Max.X-area.Min.X)
+ }
+}
+
+// InsertCell inserts new cells at the given position, with the given optional
+// cell, within the specified rectangles. If no rectangles are specified, it
+// inserts cells in the entire buffer. This follows terminal [ansi.ICH]
+// behavior.
+func (b *RenderBuffer) InsertCell(x, y, n int, c *Cell) {
+ b.InsertCellArea(x, y, n, c, b.Bounds())
+}
+
+// InsertCellArea inserts new cells at the given position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's bounds are affected, following terminal [ansi.ICH] behavior.
+func (b *RenderBuffer) InsertCellArea(x, y, n int, c *Cell, area Rectangle) {
+ b.Buffer.InsertCellArea(x, y, n, c, area)
+ if x+n > area.Max.X {
+ n = area.Max.X - x
+ }
+ b.TouchLine(x, y, n)
+}
+
+// DeleteCell deletes cells at the given position, with the given optional
+// cell, within the specified rectangles. If no rectangles are specified, it
+// deletes cells in the entire buffer. This follows terminal [ansi.DCH]
+// behavior.
+func (b *RenderBuffer) DeleteCell(x, y, n int, c *Cell) {
+ b.DeleteCellArea(x, y, n, c, b.Bounds())
+}
+
+// DeleteCellArea deletes cells at the given position, with the given
+// optional cell, within the rectangle bounds. Only cells within the
+// rectangle's bounds are affected, following terminal [ansi.DCH] behavior.
+func (b *RenderBuffer) DeleteCellArea(x, y, n int, c *Cell, area Rectangle) {
+ b.Buffer.DeleteCellArea(x, y, n, c, area)
+ remainingCells := area.Max.X - x
+ if n > remainingCells {
+ n = remainingCells
+ }
+ b.TouchLine(x, y, n)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/cancelreader_other.go b/vendor/github.com/charmbracelet/ultraviolet/cancelreader_other.go
new file mode 100644
index 000000000..3fb3c95ce
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/cancelreader_other.go
@@ -0,0 +1,16 @@
+//go:build !windows
+// +build !windows
+
+package uv
+
+import (
+ "io"
+
+ "github.com/muesli/cancelreader"
+)
+
+// NewCancelReader creates a new [cancelreader.CancelReader] that provides a
+// cancelable reader interface that can be used to cancel reads.
+func NewCancelReader(r io.Reader) (cancelreader.CancelReader, error) {
+ return cancelreader.NewReader(r) //nolint:wrapcheck
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/cancelreader_windows.go b/vendor/github.com/charmbracelet/ultraviolet/cancelreader_windows.go
new file mode 100644
index 000000000..fdc2db584
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/cancelreader_windows.go
@@ -0,0 +1,139 @@
+//go:build windows
+// +build windows
+
+package uv
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "sync"
+
+ xwindows "github.com/charmbracelet/x/windows"
+ "github.com/muesli/cancelreader"
+ "golang.org/x/sys/windows"
+)
+
+type conInputReader struct {
+ cancelMixin
+ conin windows.Handle
+ originalMode uint32
+ newMode uint32
+}
+
+var _ cancelreader.CancelReader = &conInputReader{}
+
+// NewCancelReader creates a new [cancelreader.CancelReader] that provides a
+// cancelable reader interface that can be used to cancel reads.
+func NewCancelReader(r io.Reader) (cancelreader.CancelReader, error) {
+ fallback := func(io.Reader) (cancelreader.CancelReader, error) {
+ return cancelreader.NewReader(r)
+ }
+
+ var dummy uint32
+ if f, ok := r.(cancelreader.File); !ok || f.Fd() != os.Stdin.Fd() ||
+ // If data was piped to the standard input, it does not emit events
+ // anymore. We can detect this if the console mode cannot be set anymore,
+ // in this case, we fallback to the default cancelreader implementation.
+ windows.GetConsoleMode(windows.Handle(f.Fd()), &dummy) != nil {
+ return fallback(r)
+ }
+
+ conin, err := windows.GetStdHandle(windows.STD_INPUT_HANDLE)
+ if err != nil {
+ return fallback(r)
+ }
+
+ // Discard any pending input events.
+ if err := xwindows.FlushConsoleInputBuffer(conin); err != nil {
+ return fallback(r)
+ }
+
+ modes := []uint32{
+ windows.ENABLE_VIRTUAL_TERMINAL_INPUT,
+ windows.ENABLE_WINDOW_INPUT,
+ windows.ENABLE_EXTENDED_FLAGS,
+ }
+
+ originalMode, newMode, err := prepareConsole(conin, modes...)
+ if err != nil {
+ return nil, fmt.Errorf("failed to prepare console input: %w", err)
+ }
+
+ return &conInputReader{
+ conin: conin,
+ originalMode: originalMode,
+ newMode: newMode,
+ }, nil
+}
+
+// Cancel implements cancelreader.CancelReader.
+func (r *conInputReader) Cancel() bool {
+ r.setCanceled()
+
+ return windows.CancelIoEx(r.conin, nil) == nil || windows.CancelIo(r.conin) == nil
+}
+
+// Close implements cancelreader.CancelReader.
+func (r *conInputReader) Close() error {
+ if r.originalMode != 0 {
+ err := windows.SetConsoleMode(r.conin, r.originalMode)
+ if err != nil {
+ return fmt.Errorf("reset console mode: %w", err)
+ }
+ }
+
+ return nil
+}
+
+// Read implements cancelreader.CancelReader.
+func (r *conInputReader) Read(data []byte) (int, error) {
+ if r.isCanceled() {
+ return 0, cancelreader.ErrCanceled
+ }
+
+ var n uint32
+ if err := windows.ReadFile(r.conin, data, &n, nil); err != nil {
+ return int(n), fmt.Errorf("read console input: %w", err)
+ }
+
+ return int(n), nil
+}
+
+func prepareConsole(input windows.Handle, modes ...uint32) (originalMode, newMode uint32, err error) {
+ err = windows.GetConsoleMode(input, &originalMode)
+ if err != nil {
+ return 0, 0, fmt.Errorf("get console mode: %w", err)
+ }
+
+ for _, mode := range modes {
+ newMode |= mode
+ }
+
+ err = windows.SetConsoleMode(input, newMode)
+ if err != nil {
+ return 0, 0, fmt.Errorf("set console mode: %w", err)
+ }
+
+ return originalMode, newMode, nil
+}
+
+// cancelMixin represents a goroutine-safe cancelation status.
+type cancelMixin struct {
+ unsafeCanceled bool
+ lock sync.Mutex
+}
+
+func (c *cancelMixin) setCanceled() {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ c.unsafeCanceled = true
+}
+
+func (c *cancelMixin) isCanceled() bool {
+ c.lock.Lock()
+ defer c.lock.Unlock()
+
+ return c.unsafeCanceled
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/cell.go b/vendor/github.com/charmbracelet/ultraviolet/cell.go
new file mode 100644
index 000000000..ea89b553a
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/cell.go
@@ -0,0 +1,459 @@
+package uv
+
+import (
+ "image/color"
+ "strings"
+
+ "github.com/charmbracelet/colorprofile"
+ "github.com/charmbracelet/x/ansi"
+)
+
+// EmptyCell is a cell with a single space, width of 1, and no style or link.
+var EmptyCell = Cell{Content: " ", Width: 1}
+
+// Cell represents a single cell in the terminal screen.
+type Cell struct {
+ // Content is the [Cell]'s content, which consists of a single grapheme
+ // cluster. Most of the time, this will be a single rune as well, but it
+ // can also be a combination of runes that form a grapheme cluster.
+ Content string
+
+ // The style of the cell. Nil style means no style. Zero value prints a
+ // reset sequence.
+ Style Style
+
+ // Link is the hyperlink of the cell.
+ Link Link
+
+ // Width is the mono-spaced width of the grapheme cluster.
+ Width int
+}
+
+// NewCell creates a new cell from the given string grapheme. It will only use
+// the first grapheme in the string and ignore the rest. The width of the cell
+// is determined using the given width method.
+func NewCell(method WidthMethod, gr string) *Cell {
+ if len(gr) == 0 {
+ return &Cell{}
+ }
+ if gr == " " {
+ return EmptyCell.Clone()
+ }
+ return &Cell{
+ Content: gr,
+ Width: method.StringWidth(gr),
+ }
+}
+
+// String returns the string content of the cell excluding any styles, links,
+// and escape sequences.
+func (c *Cell) String() string {
+ return c.Content
+}
+
+// Equal returns whether the cell is equal to the other cell.
+func (c *Cell) Equal(o *Cell) bool {
+ return o != nil &&
+ c.Width == o.Width &&
+ c.Content == o.Content &&
+ c.Style.Equal(&o.Style) &&
+ c.Link.Equal(&o.Link)
+}
+
+// IsZero returns whether the cell is an empty cell.
+func (c *Cell) IsZero() bool {
+ return *c == Cell{}
+}
+
+// Clone returns a copy of the cell.
+func (c *Cell) Clone() (n *Cell) {
+ n = new(Cell)
+ *n = *c
+ return
+}
+
+// Empty makes the cell an empty cell by setting its content to a single space
+// and width to 1.
+func (c *Cell) Empty() {
+ c.Content = " "
+ c.Width = 1
+}
+
+// NewLink creates a new hyperlink with the given URL and parameters.
+func NewLink(url string, params ...string) Link {
+ return Link{
+ URL: url,
+ Params: strings.Join(params, ":"),
+ }
+}
+
+// Link represents a hyperlink in the terminal screen.
+type Link struct {
+ URL string
+ Params string
+}
+
+// String returns a string representation of the hyperlink.
+func (h *Link) String() string {
+ return h.URL
+}
+
+// Equal returns whether the hyperlink is equal to the other hyperlink.
+func (h *Link) Equal(o *Link) bool {
+ return o != nil && *h == *o
+}
+
+// IsZero returns whether the hyperlink is empty.
+func (h *Link) IsZero() bool {
+ return *h == Link{}
+}
+
+// These are the available text attributes that can be combined to create
+// different styles.
+const (
+ AttrBold = 1 << iota
+ AttrFaint
+ AttrItalic
+ AttrBlink
+ AttrRapidBlink // Not widely supported
+ AttrReverse
+ AttrConceal
+ AttrStrikethrough
+
+ AttrReset = 0
+)
+
+// AttrSlowBlink is an alias for AttrBlink.
+//
+// Deprecated: Use [AttrBlink] instead.
+const (
+ AttrSlowBlink = AttrBlink
+)
+
+// Underline is the style of underline to use for text.
+type Underline = ansi.Underline
+
+// UnderlineStyle is the style of underline to use for text.
+//
+// Deprecated: Use [Underline] instead.
+type UnderlineStyle = ansi.Underline
+
+// These are the available underline styles.
+const (
+ UnderlineNone = ansi.UnderlineNone
+ UnderlineSingle = ansi.UnderlineSingle
+ UnderlineDouble = ansi.UnderlineDouble
+ UnderlineCurly = ansi.UnderlineCurly
+ UnderlineDotted = ansi.UnderlineDotted
+ UnderlineDashed = ansi.UnderlineDashed
+)
+
+// These are the available underline styles.
+//
+// Deprecated: Use the constants from [Underline] instead.
+const (
+ UnderlineStyleNone = ansi.UnderlineNone
+ UnderlineStyleSingle = ansi.UnderlineSingle
+ UnderlineStyleDouble = ansi.UnderlineDouble
+ UnderlineStyleCurly = ansi.UnderlineCurly
+ UnderlineStyleDotted = ansi.UnderlineDotted
+ UnderlineStyleDashed = ansi.UnderlineDashed
+)
+
+// Style represents the style of a cell.
+type Style struct {
+ Fg color.Color
+ Bg color.Color
+ UnderlineColor color.Color
+ Underline Underline
+ Attrs uint8
+}
+
+// Equal returns true if the style is equal to the other style.
+func (s *Style) Equal(o *Style) bool {
+ return s.Attrs == o.Attrs &&
+ s.Underline == o.Underline &&
+ colorEqual(s.Fg, o.Fg) &&
+ colorEqual(s.Bg, o.Bg) &&
+ colorEqual(s.UnderlineColor, o.UnderlineColor)
+}
+
+// Styled wraps the given string with the style's ANSI sequences and resets.
+func (s *Style) Styled(str string) string {
+ if s.IsZero() {
+ return str
+ }
+ return s.String() + str + ansi.ResetStyle
+}
+
+// String returns the ANSI SGR sequence for the style.
+func (s *Style) String() string {
+ if s.IsZero() {
+ return ansi.ResetStyle
+ }
+
+ var b ansi.Style
+
+ if s.Attrs != 0 { //nolint:nestif
+ if s.Attrs&AttrBold != 0 {
+ b = b.Bold()
+ }
+ if s.Attrs&AttrFaint != 0 {
+ b = b.Faint()
+ }
+ if s.Attrs&AttrItalic != 0 {
+ b = b.Italic(true)
+ }
+ if s.Attrs&AttrBlink != 0 {
+ b = b.Blink(true)
+ }
+ if s.Attrs&AttrRapidBlink != 0 {
+ b = b.RapidBlink(true)
+ }
+ if s.Attrs&AttrReverse != 0 {
+ b = b.Reverse(true)
+ }
+ if s.Attrs&AttrConceal != 0 {
+ b = b.Conceal(true)
+ }
+ if s.Attrs&AttrStrikethrough != 0 {
+ b = b.Strikethrough(true)
+ }
+ }
+ if s.Underline != UnderlineStyleNone {
+ switch s.Underline {
+ case UnderlineStyleSingle:
+ b = b.Underline(true)
+ case UnderlineStyleDouble:
+ b = b.UnderlineStyle(UnderlineStyleDouble)
+ case UnderlineStyleCurly:
+ b = b.UnderlineStyle(UnderlineStyleCurly)
+ case UnderlineStyleDotted:
+ b = b.UnderlineStyle(UnderlineStyleDotted)
+ case UnderlineStyleDashed:
+ b = b.UnderlineStyle(UnderlineStyleDashed)
+ }
+ }
+ if s.Fg != nil {
+ b = b.ForegroundColor(s.Fg)
+ }
+ if s.Bg != nil {
+ b = b.BackgroundColor(s.Bg)
+ }
+ if s.UnderlineColor != nil {
+ b = b.UnderlineColor(s.UnderlineColor)
+ }
+
+ return b.String()
+}
+
+// Diff returns the ANSI sequence that sets the style as a diff from
+// another style.
+func (s *Style) Diff(from *Style) string {
+ return StyleDiff(from, s)
+}
+
+// StyleDiff returns the SGR ANSI sequence necessary to transition from the
+// "from" style to the "to" style.
+func StyleDiff(from, to *Style) string {
+ if from == nil && to == nil {
+ return ""
+ }
+ if from != nil && to != nil && from.Equal(to) {
+ return ""
+ }
+ if from == nil {
+ return to.String()
+ }
+ if to == nil || to.IsZero() {
+ // Resetting all styles is cheaper than calculating diffs.
+ // "\x1b[m" is 3 bytes vs potentially much longer sequences.
+ return ansi.ResetStyle
+ }
+
+ // TODO: Optimize further by checking if a full reset is cheaper than
+ // calculating diffs. Often, it might be cheaper to reset everything and
+ // then set the desired styles rather than calculating diffs. Also more
+ // compatible with terminals that have buggy SGR implementations.
+
+ var b ansi.Style
+
+ if !colorEqual(from.Fg, to.Fg) {
+ b = b.ForegroundColor(to.Fg)
+ }
+
+ if !colorEqual(from.Bg, to.Bg) {
+ b = b.BackgroundColor(to.Bg)
+ }
+
+ if !colorEqual(from.UnderlineColor, to.UnderlineColor) {
+ // TODO: Investigate this. For backward compatibility, we might want to
+ // set this at the end instead. Because on terminals that don't support
+ // underline color, this might mess up some other attributes if set in
+ // the middle.
+ b = b.UnderlineColor(to.UnderlineColor)
+ }
+
+ fromBold := from.Attrs&AttrBold != 0
+ fromFaint := from.Attrs&AttrFaint != 0
+ fromItalic := from.Attrs&AttrItalic != 0
+ fromUnderline := from.Underline != UnderlineStyleNone
+ fromBlink := from.Attrs&AttrBlink != 0
+ fromRapidBlink := from.Attrs&AttrRapidBlink != 0
+ fromReverse := from.Attrs&AttrReverse != 0
+ fromConceal := from.Attrs&AttrConceal != 0
+ fromStrikethrough := from.Attrs&AttrStrikethrough != 0
+ toBold := to.Attrs&AttrBold != 0
+ toFaint := to.Attrs&AttrFaint != 0
+ toItalic := to.Attrs&AttrItalic != 0
+ toUnderline := to.Underline != UnderlineStyleNone
+ toBlink := to.Attrs&AttrBlink != 0
+ toRapidBlink := to.Attrs&AttrRapidBlink != 0
+ toReverse := to.Attrs&AttrReverse != 0
+ toConceal := to.Attrs&AttrConceal != 0
+ toStrikethrough := to.Attrs&AttrStrikethrough != 0
+
+ // We perform the resets first since they are single attributes and
+ // shouldn't interfere with others being set.
+
+ boldChanged := fromBold != toBold
+ faintChanged := fromFaint != toFaint
+ if boldChanged || faintChanged {
+ if fromBold && !toBold || fromFaint && !toFaint {
+ b = b.Normal()
+ boldChanged = true
+ faintChanged = true
+ }
+ }
+
+ italicChanged := fromItalic != toItalic
+ if italicChanged && !toItalic {
+ b = b.Italic(false)
+ }
+
+ underlineChanged := fromUnderline != toUnderline || from.Underline != to.Underline
+ if underlineChanged && !toUnderline {
+ b = b.Underline(false)
+ }
+
+ blinkChanged := fromBlink != toBlink
+ rapidBlinkChanged := fromRapidBlink != toRapidBlink
+ if blinkChanged || rapidBlinkChanged {
+ if fromBlink && !toBlink || fromRapidBlink && !toRapidBlink {
+ b = b.Blink(false)
+ blinkChanged = true
+ rapidBlinkChanged = true
+ }
+ }
+
+ reverseChanged := fromReverse != toReverse
+ if reverseChanged && !toReverse {
+ b = b.Reverse(false)
+ }
+
+ concealChanged := fromConceal != toConceal
+ if concealChanged && !toConceal {
+ b = b.Conceal(false)
+ }
+
+ strikethroughChanged := fromStrikethrough != toStrikethrough
+ if strikethroughChanged && !toStrikethrough {
+ b = b.Strikethrough(false)
+ }
+
+ if boldChanged && toBold {
+ b = b.Bold()
+ }
+
+ if faintChanged && toFaint {
+ b = b.Faint()
+ }
+
+ if italicChanged && toItalic {
+ b = b.Italic(true)
+ }
+
+ if underlineChanged && toUnderline && to.Underline == UnderlineStyleSingle {
+ // We only handle single underline here since others require more
+ // specific handling at the end.
+ b = b.Underline(true)
+ }
+
+ if blinkChanged && toBlink {
+ b = b.Blink(true)
+ }
+
+ if rapidBlinkChanged && toRapidBlink {
+ b = b.RapidBlink(true)
+ }
+
+ if reverseChanged && toReverse {
+ b = b.Reverse(true)
+ }
+
+ if concealChanged && toConceal {
+ b = b.Conceal(true)
+ }
+
+ if strikethroughChanged && toStrikethrough {
+ b = b.Strikethrough(true)
+ }
+
+ // Handle special underline styles.
+ if underlineChanged && toUnderline && to.Underline > UnderlineStyleSingle {
+ b = b.UnderlineStyle(to.Underline)
+ }
+
+ return b.String()
+}
+
+func colorEqual(c, o color.Color) bool {
+ if c == nil && o == nil {
+ return true
+ }
+ if c == nil || o == nil {
+ return false
+ }
+ cr, cg, cb, ca := c.RGBA()
+ or, og, ob, oa := o.RGBA()
+ return cr == or && cg == og && cb == ob && ca == oa
+}
+
+// IsZero returns true if the style is empty.
+func (s *Style) IsZero() bool {
+ return *s == Style{}
+}
+
+// ConvertStyle converts a style to respect the given color profile.
+func ConvertStyle(s Style, p colorprofile.Profile) Style {
+ switch p {
+ case colorprofile.TrueColor:
+ return s
+ case colorprofile.ANSI, colorprofile.ANSI256:
+ case colorprofile.Ascii:
+ s.Fg = nil
+ s.Bg = nil
+ s.UnderlineColor = nil
+ case colorprofile.NoTTY:
+ return Style{}
+ }
+
+ if s.Fg != nil {
+ s.Fg = p.Convert(s.Fg)
+ }
+ if s.Bg != nil {
+ s.Bg = p.Convert(s.Bg)
+ }
+ if s.UnderlineColor != nil {
+ s.UnderlineColor = p.Convert(s.UnderlineColor)
+ }
+ return s
+}
+
+// ConvertLink converts a hyperlink to respect the given color profile.
+func ConvertLink(h Link, p colorprofile.Profile) Link {
+ if p == colorprofile.NoTTY {
+ return Link{}
+ }
+ return h
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/console.go b/vendor/github.com/charmbracelet/ultraviolet/console.go
new file mode 100644
index 000000000..7ef37fd60
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/console.go
@@ -0,0 +1,219 @@
+package uv
+
+import (
+ "io"
+ "os"
+ "runtime"
+
+ "github.com/charmbracelet/x/term"
+)
+
+var isWindows = runtime.GOOS == "windows"
+
+// File is an interface that represents a file with a file descriptor.
+//
+// This is typically an [os.File] like [os.Stdin] and [os.Stdout].
+type File interface {
+ io.ReadWriteCloser
+ term.File
+
+ // Name returns the name of the file.
+ Name() string
+}
+
+// Winsize represents the size of a terminal in cells and pixels.
+//
+// This is the same as [unix.Winsize], but defined here for cross-platform compatibility.
+type Winsize struct {
+ Row uint16
+ Col uint16
+ Xpixel uint16
+ Ypixel uint16
+}
+
+// Console represents a cross-platform console I/O interface.
+type Console interface {
+ io.ReadWriteCloser
+
+ // Environ returns the console's environment variables.
+ Environ() []string
+
+ // Getenv retrieves the value of the environment variable named by the key.
+ Getenv(key string) string
+
+ // LookupEnv retrieves the value of the environment variable named by the key
+ // and a boolean indicating whether the variable is present.
+ LookupEnv(key string) (string, bool)
+
+ // Reader returns the input reader of the console.
+ Reader() io.Reader
+
+ // Writer returns the output writer of the console.
+ Writer() io.Writer
+
+ // MakeRaw puts the console input side into raw mode.
+ MakeRaw() (state *term.State, err error)
+
+ // Restore restores the console to its previous state.
+ Restore() error
+
+ // GetSize returns the current size of the console.
+ GetSize() (width, height int, err error)
+
+ // GetWinsize returns the current size of the console in cells and pixels.
+ GetWinsize() (*Winsize, error)
+}
+
+// TTY represents a Unix TTY device. It implements the [Console] interface.
+type TTY struct {
+ *console
+}
+
+var _ Console = (*TTY)(nil)
+
+// WinCon represents a Windows Console. It implements the [Console] interface.
+type WinCon struct {
+ *console
+}
+
+var _ Console = (*WinCon)(nil)
+
+// Console is a cross-platform console I/O.
+type console struct {
+ input File
+ inputState *term.State
+ output File
+ outputState *term.State
+ environ Environ
+}
+
+// DefaultConsole returns a new default console instance that uses standard I/O
+// [os.Stdin], [os.Stdout], and [os.Environ].
+//
+// To use [os.Stderr] as the output, you can create a new console with
+// [NewConsole] and pass [os.Stderr] as the output parameter.
+func DefaultConsole() Console {
+ return NewConsole(os.Stdin, os.Stdout, os.Environ())
+}
+
+// ControllingConsole returns a new console instance that uses the current
+// controlling terminal's input and output file descriptors.
+func ControllingConsole() (Console, error) {
+ inTty, outTty, err := OpenTTY()
+ if err != nil {
+ return nil, err
+ }
+ return NewConsole(inTty, outTty, os.Environ()), nil
+}
+
+// NewConsole creates a new [Console] with the given input, output, and
+// environment variables.
+//
+// You can use [OpenTTY] to open the current controlling console files and pass
+// them to this function. Use [ControllingConsole] for a convenience function
+// that does this for you.
+//
+// Use this to create a new terminal for PTY processes by passing the PTY slave
+// file as the input and output and any environment variables the process
+// needs.
+func NewConsole(input, output File, environ []string) Console {
+ if input == nil {
+ input = os.Stdin
+ }
+ if output == nil {
+ output = os.Stdout
+ }
+ if environ == nil {
+ environ = os.Environ()
+ }
+ return newConsole(input, output, environ)
+}
+
+// Environ returns the console's environment variables.
+func (t *console) Environ() []string {
+ return t.environ
+}
+
+// Writer returns the output writer of the console.
+func (t *console) Writer() io.Writer {
+ return t.output
+}
+
+// Reader returns the input reader of the console.
+func (t *console) Reader() io.Reader {
+ return t.input
+}
+
+// Write writes data to the console's output.
+func (t *console) Write(p []byte) (n int, err error) {
+ return t.output.Write(p)
+}
+
+// Read reads data from the console's input.
+func (t *console) Read(p []byte) (n int, err error) {
+ return t.input.Read(p)
+}
+
+// Getenv retrieves the value of the environment variable named by the key.
+func (t *console) Getenv(key string) string {
+ return t.environ.Getenv(key)
+}
+
+// LookupEnv retrieves the value of the environment variable named by the key
+// and a boolean indicating whether the variable is present.
+func (t *console) LookupEnv(key string) (string, bool) {
+ return t.environ.LookupEnv(key)
+}
+
+// MakeRaw puts the console input side into raw mode.
+func (t *console) MakeRaw() (state *term.State, err error) {
+ inState, outState, err := makeRaw(t.input, t.output)
+ if err != nil {
+ return nil, err
+ }
+ t.inputState = inState
+ t.outputState = outState
+ if inState != nil {
+ return inState, nil
+ }
+ return outState, nil
+}
+
+// Restore restores the console to its previous state.
+func (t *console) Restore() error {
+ if t.inputState != nil {
+ if err := term.Restore(t.input.Fd(), t.inputState); err != nil {
+ return err
+ }
+ t.inputState = nil
+ }
+ if t.outputState != nil {
+ if err := term.Restore(t.output.Fd(), t.outputState); err != nil {
+ return err
+ }
+ t.outputState = nil
+ }
+ return nil
+}
+
+// Close restores the console to its previous state and releases resources.
+func (t *console) Close() error {
+ if err := t.Restore(); err != nil {
+ return err
+ }
+ return nil
+}
+
+// GetSize returns the current size of the console.
+func (t *console) GetSize() (width, height int, err error) {
+ return getSize(t.input, t.output)
+}
+
+// GetWinsize returns the current size of the console in cells and pixels.
+func (t *console) GetWinsize() (*Winsize, error) {
+ ws, err := getWinsize(t.input, t.output)
+ if err != nil {
+ return nil, err
+ }
+ return &ws, nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/console_unix.go b/vendor/github.com/charmbracelet/ultraviolet/console_unix.go
new file mode 100644
index 000000000..5460effff
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/console_unix.go
@@ -0,0 +1,13 @@
+//go:build !windows
+// +build !windows
+
+package uv
+
+func newConsole(in File, out File, env Environ) *TTY {
+ c := &console{
+ input: in,
+ output: out,
+ environ: env,
+ }
+ return &TTY{console: c}
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/console_windows.go b/vendor/github.com/charmbracelet/ultraviolet/console_windows.go
new file mode 100644
index 000000000..0836f1c38
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/console_windows.go
@@ -0,0 +1,13 @@
+//go:build windows
+// +build windows
+
+package uv
+
+func newConsole(in File, out File, env Environ) *WinCon {
+ c := &console{
+ input: in,
+ output: out,
+ environ: env,
+ }
+ return &WinCon{console: c}
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/cursor.go b/vendor/github.com/charmbracelet/ultraviolet/cursor.go
new file mode 100644
index 000000000..33a3843a8
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/cursor.go
@@ -0,0 +1,22 @@
+package uv
+
+// CursorShape represents a terminal cursor shape.
+type CursorShape int
+
+// Cursor shapes.
+const (
+ CursorBlock CursorShape = iota
+ CursorUnderline
+ CursorBar
+)
+
+// Encode returns the encoded value for the cursor shape.
+func (s CursorShape) Encode(blink bool) int {
+ // We're using the ANSI escape sequence values for cursor styles.
+ // We need to map both [style] and [steady] to the correct value.
+ s = (s * 2) + 1 //nolint:mnd
+ if !blink {
+ s++
+ }
+ return int(s)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/decoder.go b/vendor/github.com/charmbracelet/ultraviolet/decoder.go
new file mode 100644
index 000000000..45ef17d72
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/decoder.go
@@ -0,0 +1,2103 @@
+package uv
+
+import (
+ "bytes"
+ "encoding/base64"
+ "encoding/hex"
+ "fmt"
+ "image/color"
+ "math"
+ "slices"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/charmbracelet/x/ansi/parser"
+ xwindows "github.com/charmbracelet/x/windows"
+ "github.com/rivo/uniseg"
+)
+
+// Flags to control the behavior of the parser.
+const (
+ // When this flag is set, the driver will treat both Ctrl+Space and Ctrl+@
+ // as the same key sequence.
+ //
+ // Historically, the ANSI specs generate NUL (0x00) on both the Ctrl+Space
+ // and Ctrl+@ key sequences. This flag allows the driver to treat both as
+ // the same key sequence.
+ flagCtrlAt = 1 << iota
+
+ // When this flag is set, the driver will treat the Tab key and Ctrl+I as
+ // the same key sequence.
+ //
+ // Historically, the ANSI specs generate HT (0x09) on both the Tab key and
+ // Ctrl+I. This flag allows the driver to treat both as the same key
+ // sequence.
+ flagCtrlI
+
+ // When this flag is set, the driver will treat the Enter key and Ctrl+M as
+ // the same key sequence.
+ //
+ // Historically, the ANSI specs generate CR (0x0D) on both the Enter key
+ // and Ctrl+M. This flag allows the driver to treat both as the same key.
+ flagCtrlM
+
+ // When this flag is set, the driver will treat Escape and Ctrl+[ as
+ // the same key sequence.
+ //
+ // Historically, the ANSI specs generate ESC (0x1B) on both the Escape key
+ // and Ctrl+[. This flag allows the driver to treat both as the same key
+ // sequence.
+ flagCtrlOpenBracket
+
+ // When this flag is set, the driver will send a BS (0x08 byte) character
+ // instead of a DEL (0x7F byte) character when the Backspace key is
+ // pressed.
+ //
+ // The VT100 terminal has both a Backspace and a Delete key. The VT220
+ // terminal dropped the Backspace key and replaced it with the Delete key.
+ // Both terminals send a DEL character when the Delete key is pressed.
+ // Modern terminals and PCs later readded the Delete key but used a
+ // different key sequence, and the Backspace key was standardized to send a
+ // DEL character.
+ flagBackspace
+
+ // When this flag is set, the driver will recognize the Find key instead of
+ // treating it as a Home key.
+ //
+ // The Find key was part of the VT220 keyboard, and is no longer used in
+ // modern day PCs.
+ flagFind
+
+ // When this flag is set, the driver will recognize the Select key instead
+ // of treating it as a End key.
+ //
+ // The Symbol key was part of the VT220 keyboard, and is no longer used in
+ // modern day PCs.
+ flagSelect
+
+ // When this flag is set, the driver will preserve function keys (F13-F63)
+ // as symbols.
+ //
+ // Since these keys are not part of today's standard 20th century keyboard,
+ // we treat them as F1-F12 modifier keys i.e. ctrl/shift/alt + Fn combos.
+ // Key definitions come from Terminfo, this flag is only useful when
+ // FlagTerminfo is not set.
+ flagFKeys
+)
+
+// LegacyKeyEncoding is a set of flags that control the behavior of legacy
+// terminal key encodings. Historically, ctrl+
+ code := rune(b) - 0x40
+ return 1, KeyPressEvent{Code: code, Mod: ModCtrl | ModAlt}
+ }
+ return p.parseUtf8(buf)
+ }
+}
+
+func (p *EventDecoder) parseCsi(b []byte) (int, Event) {
+ if len(b) == 2 && b[0] == ansi.ESC {
+ // short cut if this is an alt+[ key
+ return 2, KeyPressEvent{Code: rune(b[1]), Mod: ModAlt}
+ }
+
+ var cmd ansi.Cmd
+ var params [parser.MaxParamsSize]ansi.Param
+ var paramsLen int
+
+ var i int
+ if b[i] == ansi.CSI || b[i] == ansi.ESC {
+ i++
+ }
+ if i < len(b) && b[i-1] == ansi.ESC && b[i] == '[' {
+ i++
+ }
+
+ // Initial CSI byte
+ if i < len(b) && b[i] >= '<' && b[i] <= '?' {
+ cmd |= ansi.Cmd(b[i]) << parser.PrefixShift
+ }
+
+ // Scan parameter bytes in the range 0x30-0x3F
+ var j int
+ for j = 0; i < len(b) && paramsLen < len(params) && b[i] >= 0x30 && b[i] <= 0x3F; i, j = i+1, j+1 {
+ if b[i] >= '0' && b[i] <= '9' {
+ if params[paramsLen] == parser.MissingParam {
+ params[paramsLen] = 0
+ }
+ params[paramsLen] *= 10
+ params[paramsLen] += ansi.Param(b[i]) - '0'
+ }
+ if b[i] == ':' {
+ params[paramsLen] |= parser.HasMoreFlag
+ }
+ if b[i] == ';' || b[i] == ':' {
+ paramsLen++
+ if paramsLen < len(params) {
+ // Don't overflow the params slice
+ params[paramsLen] = parser.MissingParam
+ }
+ }
+ }
+
+ if j > 0 && paramsLen < len(params) {
+ // has parameters
+ paramsLen++
+ }
+
+ // Scan intermediate bytes in the range 0x20-0x2F
+ var intermed byte
+ for ; i < len(b) && b[i] >= 0x20 && b[i] <= 0x2F; i++ {
+ intermed = b[i]
+ }
+
+ // Set the intermediate byte
+ cmd |= ansi.Cmd(intermed) << parser.IntermedShift
+
+ // Scan final byte in the range 0x40-0x7E
+ if i >= len(b) || b[i] < 0x40 || b[i] > 0x7E {
+ // Special case for URxvt keys
+ // CSI $ is an invalid sequence, but URxvt uses it for
+ // shift modified keys.
+ if intermed == '$' && b[i-1] == '$' {
+ buf := slices.Clone(b[:i-1])
+ n, ev := p.parseCsi(append(buf, '~'))
+ if k, ok := ev.(KeyPressEvent); ok {
+ k.Mod |= ModShift
+ return n, k
+ }
+ }
+ return i, UnknownEvent(b[:i])
+ }
+
+ // Add the final byte
+ cmd |= ansi.Cmd(b[i])
+ i++
+
+ pa := ansi.Params(params[:paramsLen])
+ switch cmd {
+ case 'y' | '?'<'<'< R (which is modified F3) when the cursor is at the
+ // row 1. In this case, we report both messages.
+ //
+ // For a non ambiguous cursor position report, use
+ // [ansi.RequestExtendedCursorPosition] (DECXCPR) instead.
+ return i, MultiEvent{KeyPressEvent{Code: KeyF3, Mod: KeyMod(col - 1)}, m}
+ }
+
+ return i, m
+ }
+
+ if paramsLen != 0 {
+ break
+ }
+
+ // Unmodified key F3 (CSI R)
+ fallthrough
+ case 'a', 'b', 'c', 'd', 'A', 'B', 'C', 'D', 'E', 'F', 'H', 'P', 'Q', 'S', 'Z':
+ var k KeyPressEvent
+ switch cmd {
+ case 'a', 'b', 'c', 'd':
+ k = KeyPressEvent{Code: KeyUp + rune(cmd-'a'), Mod: ModShift}
+ case 'A', 'B', 'C', 'D':
+ k = KeyPressEvent{Code: KeyUp + rune(cmd-'A')}
+ case 'E':
+ k = KeyPressEvent{Code: KeyBegin}
+ case 'F':
+ k = KeyPressEvent{Code: KeyEnd}
+ case 'H':
+ k = KeyPressEvent{Code: KeyHome}
+ case 'P', 'Q', 'R', 'S':
+ k = KeyPressEvent{Code: KeyF1 + rune(cmd-'P')}
+ case 'Z':
+ k = KeyPressEvent{Code: KeyTab, Mod: ModShift}
+ }
+ id, _, _ := pa.Param(0, 1)
+ mod, _, _ := pa.Param(1, 1)
+ if paramsLen > 2 && !pa[1].HasMore() || id != 1 {
+ break
+ }
+ if paramsLen > 1 && id == 1 && mod != -1 {
+ // CSI 1 ; A
+ k.Mod |= KeyMod(mod - 1)
+ }
+ // Don't forget to handle Kitty keyboard protocol
+ return i, parseKittyKeyboardExt(pa, k)
+ case 'M':
+ // Handle X10 mouse
+ if i+3 > len(b) {
+ return i, UnknownCsiEvent(b[:i])
+ }
+ return i + 3, parseX10MouseEvent(append(b[:i], b[i:i+3]...))
+ case 'y' | '$'< 1 && mod != -1 {
+ k.Mod |= KeyMod(mod - 1)
+ }
+
+ // Handle URxvt weird keys
+ switch cmd {
+ case '~':
+ // Don't forget to handle Kitty keyboard protocol
+ return i, parseKittyKeyboardExt(pa, k)
+ case '^':
+ k.Mod |= ModCtrl
+ case '@':
+ k.Mod |= ModCtrl | ModShift
+ }
+
+ return i, k
+ }
+
+ case 't':
+ param, _, ok := pa.Param(0, 0)
+ if !ok {
+ break
+ }
+
+ switch param {
+ case 4: // Report Terminal window size in pixels.
+ if paramsLen == 3 {
+ height, _, hOk := pa.Param(1, 0)
+ width, _, wOk := pa.Param(2, 0)
+ if !hOk || !wOk {
+ break
+ }
+ return i, PixelSizeEvent{Width: width, Height: height}
+ }
+ case 6: // Report Terminal character cell size.
+ if paramsLen == 3 {
+ height, _, hOk := pa.Param(1, 0)
+ width, _, wOk := pa.Param(2, 0)
+ if !hOk || !wOk {
+ break
+ }
+ return i, CellSizeEvent{Width: width, Height: height}
+ }
+ case 8: // Report Terminal Window size in cells.
+ if paramsLen == 3 {
+ height, _, hOk := pa.Param(1, 0)
+ width, _, wOk := pa.Param(2, 0)
+ if !hOk || !wOk {
+ break
+ }
+ return i, WindowSizeEvent{Width: width, Height: height}
+ }
+ case 48: // In band terminal size report.
+ if paramsLen == 5 {
+ cellHeight, _, chOk := pa.Param(1, 0)
+ cellWidth, _, cwOk := pa.Param(2, 0)
+ pixelHeight, _, phOk := pa.Param(3, 0)
+ pixelWidth, _, pwOk := pa.Param(4, 0)
+ if !chOk || !cwOk || !phOk || !pwOk {
+ break
+ }
+ return i, MultiEvent{
+ WindowSizeEvent{Width: cellWidth, Height: cellHeight},
+ PixelSizeEvent{Width: pixelWidth, Height: pixelHeight},
+ }
+ }
+ }
+
+ // Any other window operation event.
+
+ var winop WindowOpEvent
+ winop.Op = param
+ for j := 1; j < paramsLen; j++ {
+ val, _, ok := pa.Param(j, 0)
+ if ok {
+ winop.Args = append(winop.Args, val)
+ }
+ }
+
+ return i, winop
+ }
+ return i, UnknownCsiEvent(b[:i])
+}
+
+// parseSs3 parses a SS3 sequence.
+// See https://vt100.net/docs/vt220-rm/chapter4.html#S4.4.4.2
+func (p *EventDecoder) parseSs3(b []byte) (int, Event) {
+ if len(b) == 2 && b[0] == ansi.ESC {
+ // short cut if this is an alt+O key
+ return 2, KeyPressEvent{Code: unicode.ToLower(rune(b[1])), Mod: ModShift | ModAlt}
+ }
+
+ var i int
+ if b[i] == ansi.SS3 || b[i] == ansi.ESC {
+ i++
+ }
+ if i < len(b) && b[i-1] == ansi.ESC && b[i] == 'O' {
+ i++
+ }
+
+ // Scan numbers from 0-9
+ var mod int
+ for ; i < len(b) && b[i] >= '0' && b[i] <= '9'; i++ {
+ mod *= 10
+ mod += int(b[i]) - '0'
+ }
+
+ // Scan a GL character
+ // A GL character is a single byte in the range 0x21-0x7E
+ // See https://vt100.net/docs/vt220-rm/chapter2.html#S2.3.2
+ if i >= len(b) || b[i] < 0x21 || b[i] > 0x7E {
+ return i, UnknownEvent(b[:i])
+ }
+
+ // GL character(s)
+ gl := b[i]
+ i++
+
+ var k KeyPressEvent
+ switch gl {
+ case 'a', 'b', 'c', 'd':
+ k = KeyPressEvent{Code: KeyUp + rune(gl-'a'), Mod: ModCtrl}
+ case 'A', 'B', 'C', 'D':
+ k = KeyPressEvent{Code: KeyUp + rune(gl-'A')}
+ case 'E':
+ k = KeyPressEvent{Code: KeyBegin}
+ case 'F':
+ k = KeyPressEvent{Code: KeyEnd}
+ case 'H':
+ k = KeyPressEvent{Code: KeyHome}
+ case 'P', 'Q', 'R', 'S':
+ k = KeyPressEvent{Code: KeyF1 + rune(gl-'P')}
+ case 'M':
+ k = KeyPressEvent{Code: KeyKpEnter}
+ case 'X':
+ k = KeyPressEvent{Code: KeyKpEqual}
+ case 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y':
+ k = KeyPressEvent{Code: KeyKpMultiply + rune(gl-'j')}
+ default:
+ return i, UnknownSs3Event(b[:i])
+ }
+
+ // Handle weird SS3 Func
+ if mod > 0 {
+ k.Mod |= KeyMod(mod - 1)
+ }
+
+ return i, k
+}
+
+func (p *EventDecoder) parseOsc(b []byte) (int, Event) {
+ defaultKey := func() KeyPressEvent {
+ return KeyPressEvent{Code: rune(b[1]), Mod: ModAlt}
+ }
+ if len(b) == 2 && b[0] == ansi.ESC {
+ // short cut if this is an alt+] key
+ return 2, defaultKey()
+ }
+
+ var i int
+ if b[i] == ansi.OSC || b[i] == ansi.ESC {
+ i++
+ }
+ if i < len(b) && b[i-1] == ansi.ESC && b[i] == ']' {
+ i++
+ }
+
+ // Parse OSC command
+ // An OSC sequence is terminated by a BEL, ESC, or ST character
+ var start, end int
+ cmd := -1
+ for ; i < len(b) && b[i] >= '0' && b[i] <= '9'; i++ {
+ if cmd == -1 {
+ cmd = 0
+ } else {
+ cmd *= 10
+ }
+ cmd += int(b[i]) - '0'
+ }
+
+ if i < len(b) && b[i] == ';' {
+ // mark the start of the sequence data
+ i++
+ start = i
+ }
+
+ for ; i < len(b); i++ {
+ // advance to the end of the sequence
+ if slices.Contains([]byte{ansi.BEL, ansi.ESC, ansi.ST, ansi.CAN, ansi.SUB}, b[i]) {
+ break
+ }
+ }
+
+ if i >= len(b) {
+ return i, UnknownEvent(b[:i])
+ }
+
+ end = i // end of the sequence data
+ i++
+
+ // Check 7-bit ST (string terminator) character
+ switch b[i-1] {
+ case ansi.CAN, ansi.SUB:
+ return i, ignoredEvent(b[:i])
+ case ansi.ESC:
+ if i >= len(b) || b[i] != '\\' {
+ if cmd == -1 || (start == 0 && end == 2) {
+ return 2, defaultKey()
+ }
+
+ // If we don't have a valid ST terminator, then this is a
+ // cancelled sequence and should be ignored.
+ return i, ignoredEvent(b[:i])
+ }
+
+ i++
+ }
+
+ if end <= start {
+ return i, UnknownEvent(b[:i])
+ }
+
+ data := string(b[start:end])
+ switch cmd {
+ case 10:
+ return i, ForegroundColorEvent{ansi.XParseColor(data)}
+ case 11:
+ return i, BackgroundColorEvent{ansi.XParseColor(data)}
+ case 12:
+ return i, CursorColorEvent{ansi.XParseColor(data)}
+ case 52:
+ parts := strings.Split(data, ";")
+ if len(parts) != 2 || len(parts[0]) < 1 {
+ return i, ClipboardEvent{}
+ }
+
+ b64 := parts[1]
+ bts, err := base64.StdEncoding.DecodeString(b64)
+ if err != nil {
+ return i, ClipboardEvent{Content: parts[1]}
+ }
+
+ sel := ClipboardSelection(parts[0][0]) //nolint:unconvert
+ return i, ClipboardEvent{Selection: sel, Content: string(bts)}
+ }
+
+ return i, UnknownOscEvent(b[:i])
+}
+
+// parseStTerminated parses a control sequence that gets terminated by a ST character.
+func (p *EventDecoder) parseStTerminated(intro8, intro7 byte, fn func([]byte) Event) func([]byte) (int, Event) {
+ defaultKey := func(b []byte) (int, Event) {
+ switch intro8 {
+ case ansi.SOS:
+ return 2, KeyPressEvent{Code: unicode.ToLower(rune(b[1])), Mod: ModShift | ModAlt}
+ case ansi.PM, ansi.APC:
+ return 2, KeyPressEvent{Code: rune(b[1]), Mod: ModAlt}
+ }
+ return 0, nil
+ }
+ return func(b []byte) (int, Event) {
+ if len(b) == 2 && b[0] == ansi.ESC {
+ return defaultKey(b)
+ }
+
+ var i int
+ if b[i] == intro8 || b[i] == ansi.ESC {
+ i++
+ }
+ if i < len(b) && b[i-1] == ansi.ESC && b[i] == intro7 {
+ i++
+ }
+
+ // Scan control sequence
+ // Most common control sequence is terminated by a ST character
+ // ST is a 7-bit string terminator character is (ESC \)
+ start := i
+ for ; i < len(b); i++ {
+ if slices.Contains([]byte{ansi.ESC, ansi.ST, ansi.CAN, ansi.SUB}, b[i]) {
+ break
+ }
+ }
+
+ if i >= len(b) {
+ return i, UnknownEvent(b[:i])
+ }
+
+ end := i // end of the sequence data
+ i++
+
+ // Check 7-bit ST (string terminator) character
+ switch b[i-1] {
+ case ansi.CAN, ansi.SUB:
+ return i, ignoredEvent(b[:i])
+ case ansi.ESC:
+ if i >= len(b) || b[i] != '\\' {
+ if start == end {
+ return defaultKey(b)
+ }
+
+ // If we don't have a valid ST terminator, then this is a
+ // cancelled sequence and should be ignored.
+ return i, ignoredEvent(b[:i])
+ }
+
+ i++
+ }
+
+ // Call the function to parse the sequence and return the result
+ if fn != nil {
+ if e := fn(b[start:end]); e != nil {
+ return i, e
+ }
+ }
+
+ switch intro8 {
+ case ansi.PM:
+ return i, UnknownPmEvent(b[:i])
+ case ansi.SOS:
+ return i, UnknownSosEvent(b[:i])
+ case ansi.APC:
+ return i, UnknownApcEvent(b[:i])
+ default:
+ return i, UnknownEvent(b[:i])
+ }
+ }
+}
+
+func (p *EventDecoder) parseDcs(b []byte) (int, Event) {
+ if len(b) == 2 && b[0] == ansi.ESC {
+ // short cut if this is an alt+P key
+ return 2, KeyPressEvent{Code: unicode.ToLower(rune(b[1])), Mod: ModShift | ModAlt}
+ }
+
+ var params [16]ansi.Param
+ var paramsLen int
+ var cmd ansi.Cmd
+
+ // DCS sequences are introduced by DCS (0x90) or ESC P (0x1b 0x50)
+ var i int
+ if b[i] == ansi.DCS || b[i] == ansi.ESC {
+ i++
+ }
+ if i < len(b) && b[i-1] == ansi.ESC && b[i] == 'P' {
+ i++
+ }
+
+ // initial DCS byte
+ if i < len(b) && b[i] >= '<' && b[i] <= '?' {
+ cmd |= ansi.Cmd(b[i]) << parser.PrefixShift
+ }
+
+ // Scan parameter bytes in the range 0x30-0x3F
+ var j int
+ for j = 0; i < len(b) && paramsLen < len(params) && b[i] >= 0x30 && b[i] <= 0x3F; i, j = i+1, j+1 {
+ if b[i] >= '0' && b[i] <= '9' {
+ if params[paramsLen] == parser.MissingParam {
+ params[paramsLen] = 0
+ }
+ params[paramsLen] *= 10
+ params[paramsLen] += ansi.Param(b[i]) - '0'
+ }
+ if b[i] == ':' {
+ params[paramsLen] |= parser.HasMoreFlag
+ }
+ if b[i] == ';' || b[i] == ':' {
+ paramsLen++
+ if paramsLen < len(params) {
+ // Don't overflow the params slice
+ params[paramsLen] = parser.MissingParam
+ }
+ }
+ }
+
+ if j > 0 && paramsLen < len(params) {
+ // has parameters
+ paramsLen++
+ }
+
+ // Scan intermediate bytes in the range 0x20-0x2F
+ var intermed byte
+ for j := 0; i < len(b) && b[i] >= 0x20 && b[i] <= 0x2F; i, j = i+1, j+1 {
+ intermed = b[i]
+ }
+
+ // set intermediate byte
+ cmd |= ansi.Cmd(intermed) << parser.IntermedShift
+
+ // Scan final byte in the range 0x40-0x7E
+ if i >= len(b) || b[i] < 0x40 || b[i] > 0x7E {
+ return i, UnknownEvent(b[:i])
+ }
+
+ // Add the final byte
+ cmd |= ansi.Cmd(b[i])
+ i++
+
+ start := i // start of the sequence data
+ for ; i < len(b); i++ {
+ if b[i] == ansi.ST || b[i] == ansi.ESC {
+ break
+ }
+ }
+
+ if i >= len(b) {
+ return i, UnknownEvent(b[:i])
+ }
+
+ end := i // end of the sequence data
+ i++
+
+ // Check 7-bit ST (string terminator) character
+ if i < len(b) && b[i-1] == ansi.ESC && b[i] == '\\' {
+ i++
+ }
+
+ pa := ansi.Params(params[:paramsLen])
+ switch cmd {
+ case 'r' | '+'<'< 1 {
+ g.Payload = parts[1]
+ }
+ return g
+ }
+
+ return nil
+ })(b)
+}
+
+func (p *EventDecoder) parseUtf8(b []byte) (int, Event) {
+ if len(b) == 0 {
+ return 0, nil
+ }
+
+ c := b[0]
+ if c <= ansi.US || c == ansi.DEL {
+ // Control codes get handled by parseControl
+ return 1, p.parseControl(c)
+ } else if c > ansi.US && c < ansi.DEL {
+ // ASCII printable characters
+ code := rune(c)
+ k := KeyPressEvent{Code: code, Text: string(code)}
+ if unicode.IsUpper(code) {
+ // Convert upper case letters to lower case + shift modifier
+ k.Code = unicode.ToLower(code)
+ k.ShiftedCode = code
+ k.Mod |= ModShift
+ }
+
+ return 1, k
+ }
+
+ code, _ := utf8.DecodeRune(b)
+ if code == utf8.RuneError {
+ return 1, UnknownEvent(b[0])
+ }
+
+ cluster, _, _, _ := uniseg.FirstGraphemeCluster(b, -1)
+ text := string(cluster)
+ for i := range text {
+ if i > 0 {
+ // Use [KeyExtended] for multi-rune graphemes
+ code = KeyExtended
+ break
+ }
+ }
+
+ return len(cluster), KeyPressEvent{Code: code, Text: text}
+}
+
+func (p *EventDecoder) parseControl(b byte) Event {
+ switch b {
+ case ansi.NUL:
+ if p.Legacy&flagCtrlAt != 0 {
+ return KeyPressEvent{Code: '@', Mod: ModCtrl}
+ }
+ return KeyPressEvent{Code: KeySpace, Mod: ModCtrl}
+ case ansi.BS:
+ return KeyPressEvent{Code: 'h', Mod: ModCtrl}
+ case ansi.HT:
+ if p.Legacy&flagCtrlI != 0 {
+ return KeyPressEvent{Code: 'i', Mod: ModCtrl}
+ }
+ return KeyPressEvent{Code: KeyTab}
+ case ansi.CR:
+ if p.Legacy&flagCtrlM != 0 {
+ return KeyPressEvent{Code: 'm', Mod: ModCtrl}
+ }
+ return KeyPressEvent{Code: KeyEnter}
+ case ansi.ESC:
+ if p.Legacy&flagCtrlOpenBracket != 0 {
+ return KeyPressEvent{Code: '[', Mod: ModCtrl}
+ }
+ return KeyPressEvent{Code: KeyEscape}
+ case ansi.DEL:
+ if p.Legacy&flagBackspace != 0 {
+ return KeyPressEvent{Code: KeyDelete}
+ }
+ return KeyPressEvent{Code: KeyBackspace}
+ case ansi.SP:
+ return KeyPressEvent{Code: KeySpace, Text: " "}
+ default:
+ if b >= ansi.SOH && b <= ansi.SUB {
+ // Use lower case letters for control codes
+ code := rune(b + 0x60)
+ return KeyPressEvent{Code: code, Mod: ModCtrl}
+ } else if b >= ansi.FS && b <= ansi.US {
+ code := rune(b + 0x40)
+ return KeyPressEvent{Code: code, Mod: ModCtrl}
+ }
+ return UnknownEvent(b)
+ }
+}
+
+func parseXTermModifyOtherKeys(params ansi.Params) Event {
+ // XTerm modify other keys starts with ESC [ 27 ; ; ~
+ xmod, _, _ := params.Param(1, 1)
+ xrune, _, _ := params.Param(2, 1)
+ mod := KeyMod(xmod - 1)
+ r := rune(xrune)
+
+ switch r {
+ case ansi.BS:
+ return KeyPressEvent{Mod: mod, Code: KeyBackspace}
+ case ansi.HT:
+ return KeyPressEvent{Mod: mod, Code: KeyTab}
+ case ansi.CR:
+ return KeyPressEvent{Mod: mod, Code: KeyEnter}
+ case ansi.ESC:
+ return KeyPressEvent{Mod: mod, Code: KeyEscape}
+ case ansi.DEL:
+ return KeyPressEvent{Mod: mod, Code: KeyBackspace}
+ }
+
+ // CSI 27 ; ; ~ keys defined in XTerm modifyOtherKeys
+ k := KeyPressEvent{Code: r, Mod: mod}
+ if k.Mod <= ModShift {
+ k.Text = string(r)
+ }
+
+ return k
+}
+
+// Kitty Clipboard Control Sequences.
+var kittyKeyMap = map[int]Key{
+ ansi.BS: {Code: KeyBackspace},
+ ansi.HT: {Code: KeyTab},
+ ansi.CR: {Code: KeyEnter},
+ ansi.ESC: {Code: KeyEscape},
+ ansi.DEL: {Code: KeyBackspace},
+
+ 57344: {Code: KeyEscape},
+ 57345: {Code: KeyEnter},
+ 57346: {Code: KeyTab},
+ 57347: {Code: KeyBackspace},
+ 57348: {Code: KeyInsert},
+ 57349: {Code: KeyDelete},
+ 57350: {Code: KeyLeft},
+ 57351: {Code: KeyRight},
+ 57352: {Code: KeyUp},
+ 57353: {Code: KeyDown},
+ 57354: {Code: KeyPgUp},
+ 57355: {Code: KeyPgDown},
+ 57356: {Code: KeyHome},
+ 57357: {Code: KeyEnd},
+ 57358: {Code: KeyCapsLock},
+ 57359: {Code: KeyScrollLock},
+ 57360: {Code: KeyNumLock},
+ 57361: {Code: KeyPrintScreen},
+ 57362: {Code: KeyPause},
+ 57363: {Code: KeyMenu},
+ 57364: {Code: KeyF1},
+ 57365: {Code: KeyF2},
+ 57366: {Code: KeyF3},
+ 57367: {Code: KeyF4},
+ 57368: {Code: KeyF5},
+ 57369: {Code: KeyF6},
+ 57370: {Code: KeyF7},
+ 57371: {Code: KeyF8},
+ 57372: {Code: KeyF9},
+ 57373: {Code: KeyF10},
+ 57374: {Code: KeyF11},
+ 57375: {Code: KeyF12},
+ 57376: {Code: KeyF13},
+ 57377: {Code: KeyF14},
+ 57378: {Code: KeyF15},
+ 57379: {Code: KeyF16},
+ 57380: {Code: KeyF17},
+ 57381: {Code: KeyF18},
+ 57382: {Code: KeyF19},
+ 57383: {Code: KeyF20},
+ 57384: {Code: KeyF21},
+ 57385: {Code: KeyF22},
+ 57386: {Code: KeyF23},
+ 57387: {Code: KeyF24},
+ 57388: {Code: KeyF25},
+ 57389: {Code: KeyF26},
+ 57390: {Code: KeyF27},
+ 57391: {Code: KeyF28},
+ 57392: {Code: KeyF29},
+ 57393: {Code: KeyF30},
+ 57394: {Code: KeyF31},
+ 57395: {Code: KeyF32},
+ 57396: {Code: KeyF33},
+ 57397: {Code: KeyF34},
+ 57398: {Code: KeyF35},
+ 57399: {Code: KeyKp0},
+ 57400: {Code: KeyKp1},
+ 57401: {Code: KeyKp2},
+ 57402: {Code: KeyKp3},
+ 57403: {Code: KeyKp4},
+ 57404: {Code: KeyKp5},
+ 57405: {Code: KeyKp6},
+ 57406: {Code: KeyKp7},
+ 57407: {Code: KeyKp8},
+ 57408: {Code: KeyKp9},
+ 57409: {Code: KeyKpDecimal},
+ 57410: {Code: KeyKpDivide},
+ 57411: {Code: KeyKpMultiply},
+ 57412: {Code: KeyKpMinus},
+ 57413: {Code: KeyKpPlus},
+ 57414: {Code: KeyKpEnter},
+ 57415: {Code: KeyKpEqual},
+ 57416: {Code: KeyKpSep},
+ 57417: {Code: KeyKpLeft},
+ 57418: {Code: KeyKpRight},
+ 57419: {Code: KeyKpUp},
+ 57420: {Code: KeyKpDown},
+ 57421: {Code: KeyKpPgUp},
+ 57422: {Code: KeyKpPgDown},
+ 57423: {Code: KeyKpHome},
+ 57424: {Code: KeyKpEnd},
+ 57425: {Code: KeyKpInsert},
+ 57426: {Code: KeyKpDelete},
+ 57427: {Code: KeyKpBegin},
+ 57428: {Code: KeyMediaPlay},
+ 57429: {Code: KeyMediaPause},
+ 57430: {Code: KeyMediaPlayPause},
+ 57431: {Code: KeyMediaReverse},
+ 57432: {Code: KeyMediaStop},
+ 57433: {Code: KeyMediaFastForward},
+ 57434: {Code: KeyMediaRewind},
+ 57435: {Code: KeyMediaNext},
+ 57436: {Code: KeyMediaPrev},
+ 57437: {Code: KeyMediaRecord},
+ 57438: {Code: KeyLowerVol},
+ 57439: {Code: KeyRaiseVol},
+ 57440: {Code: KeyMute},
+ 57441: {Code: KeyLeftShift},
+ 57442: {Code: KeyLeftCtrl},
+ 57443: {Code: KeyLeftAlt},
+ 57444: {Code: KeyLeftSuper},
+ 57445: {Code: KeyLeftHyper},
+ 57446: {Code: KeyLeftMeta},
+ 57447: {Code: KeyRightShift},
+ 57448: {Code: KeyRightCtrl},
+ 57449: {Code: KeyRightAlt},
+ 57450: {Code: KeyRightSuper},
+ 57451: {Code: KeyRightHyper},
+ 57452: {Code: KeyRightMeta},
+ 57453: {Code: KeyIsoLevel3Shift},
+ 57454: {Code: KeyIsoLevel5Shift},
+}
+
+func init() {
+ // These are some faulty C0 mappings some terminals such as WezTerm have
+ // and doesn't follow the specs.
+ kittyKeyMap[ansi.NUL] = Key{Code: KeySpace, Mod: ModCtrl}
+ for i := ansi.SOH; i <= ansi.SUB; i++ {
+ if _, ok := kittyKeyMap[i]; !ok {
+ kittyKeyMap[i] = Key{Code: rune(i + 0x60), Mod: ModCtrl}
+ }
+ }
+ for i := ansi.FS; i <= ansi.US; i++ {
+ if _, ok := kittyKeyMap[i]; !ok {
+ kittyKeyMap[i] = Key{Code: rune(i + 0x40), Mod: ModCtrl}
+ }
+ }
+}
+
+const (
+ kittyShift = 1 << iota
+ kittyAlt
+ kittyCtrl
+ kittySuper
+ kittyHyper
+ kittyMeta
+ kittyCapsLock
+ kittyNumLock
+)
+
+func fromKittyMod(mod int) KeyMod {
+ var m KeyMod
+ if mod&kittyShift != 0 {
+ m |= ModShift
+ }
+ if mod&kittyAlt != 0 {
+ m |= ModAlt
+ }
+ if mod&kittyCtrl != 0 {
+ m |= ModCtrl
+ }
+ if mod&kittySuper != 0 {
+ m |= ModSuper
+ }
+ if mod&kittyHyper != 0 {
+ m |= ModHyper
+ }
+ if mod&kittyMeta != 0 {
+ m |= ModMeta
+ }
+ if mod&kittyCapsLock != 0 {
+ m |= ModCapsLock
+ }
+ if mod&kittyNumLock != 0 {
+ m |= ModNumLock
+ }
+ return m
+}
+
+// parseKittyKeyboard parses a Kitty Keyboard Protocol sequence.
+//
+// In `CSI u`, this is parsed as:
+//
+// CSI codepoint ; modifiers u
+// codepoint: ASCII Dec value
+//
+// The Kitty Keyboard Protocol extends this with optional components that can be
+// enabled progressively. The full sequence is parsed as:
+//
+// CSI unicode-key-code:alternate-key-codes ; modifiers:event-type ; text-as-codepoints u
+//
+// See https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+func parseKittyKeyboard(params ansi.Params) (Event Event) {
+ var isRelease bool
+ var key Key
+
+ // The index of parameters separated by semicolons ';'. Sub parameters are
+ // separated by colons ':'.
+ var paramIdx int
+ var sudIdx int // The sub parameter index
+ for _, p := range params {
+ // Kitty Keyboard Protocol has 3 optional components.
+ switch paramIdx {
+ case 0:
+ switch sudIdx {
+ case 0:
+ var foundKey bool
+ code := p.Param(1) // CSI u has a default value of 1
+ key, foundKey = kittyKeyMap[code]
+ if !foundKey {
+ r := rune(code)
+ if !utf8.ValidRune(r) {
+ r = utf8.RuneError
+ }
+
+ key.Code = r
+ }
+
+ case 2:
+ // shifted key + base key
+ if b := rune(p.Param(1)); unicode.IsPrint(b) {
+ // XXX: When alternate key reporting is enabled, the protocol
+ // can return 3 things, the unicode codepoint of the key,
+ // the shifted codepoint of the key, and the standard
+ // PC-101 key layout codepoint.
+ // This is useful to create an unambiguous mapping of keys
+ // when using a different language layout.
+ key.BaseCode = b
+ }
+ fallthrough
+
+ case 1:
+ // shifted key
+ if s := rune(p.Param(1)); unicode.IsPrint(s) {
+ // XXX: We swap keys here because we want the shifted key
+ // to be the Rune that is returned by the event.
+ // For example, shift+a should produce "A" not "a".
+ // In such a case, we set AltRune to the original key "a"
+ // and Rune to "A".
+ key.ShiftedCode = s
+ }
+ }
+ case 1:
+ switch sudIdx {
+ case 0:
+ mod := p.Param(1)
+ if mod > 1 {
+ key.Mod = fromKittyMod(mod - 1)
+ if key.Mod > ModShift {
+ // XXX: We need to clear the text if we have a modifier key
+ // other than a [ModShift] key.
+ key.Text = ""
+ }
+ }
+
+ case 1:
+ switch p.Param(1) {
+ case 2:
+ key.IsRepeat = true
+ case 3:
+ isRelease = true
+ }
+ case 2:
+ }
+ case 2:
+ if code := p.Param(0); code != 0 {
+ key.Text += string(rune(code))
+ }
+ }
+
+ sudIdx++
+ if !p.HasMore() {
+ paramIdx++
+ sudIdx = 0
+ }
+ }
+
+ keyMod := key.Mod
+
+ // Remove these lock modifiers from now on since they don't affect the text.
+ keyMod &^= ModNumLock
+ // keyMod &^= ModScrollLock // Kitty doesn't support scroll lock
+
+ printMod := keyMod <= ModShift || keyMod == ModCapsLock || keyMod == (ModShift|ModCapsLock)
+ printKeyPad := key.Code >= KeyKpEqual && key.Code <= KeyKpSep
+ if len(key.Text) == 0 && printKeyPad && printMod {
+ switch {
+ case key.Code >= KeyKp0 && key.Code <= KeyKp9:
+ key.Text = string('0' + key.Code - KeyKp0)
+ case key.Code == KeyKpEqual:
+ key.Text = "="
+ case key.Code == KeyKpMultiply:
+ key.Text = "*"
+ case key.Code == KeyKpPlus:
+ key.Text = "+"
+ case key.Code == KeyKpMinus:
+ key.Text = "-"
+ case key.Code == KeyKpDecimal:
+ key.Text = "."
+ case key.Code == KeyKpDivide:
+ key.Text = "/"
+ case key.Code == KeyKpSep:
+ key.Text = ","
+ }
+ }
+
+ //nolint:nestif
+ if len(key.Text) == 0 && unicode.IsPrint(key.Code) && printMod {
+ if keyMod == 0 {
+ key.Text = string(key.Code)
+ } else {
+ desiredCase := unicode.ToLower
+ if keyMod.Contains(ModShift) || keyMod.Contains(ModCapsLock) {
+ desiredCase = unicode.ToUpper
+ }
+ if key.ShiftedCode != 0 {
+ key.Text = string(key.ShiftedCode)
+ } else {
+ key.Text = string(desiredCase(key.Code))
+ }
+ }
+ }
+
+ if isRelease {
+ return KeyReleaseEvent(key)
+ }
+
+ return KeyPressEvent(key)
+}
+
+// parseKittyKeyboardExt parses a Kitty Keyboard Protocol sequence extensions
+// for non CSI u sequences. This includes things like CSI A, SS3 A and others,
+// and CSI ~.
+func parseKittyKeyboardExt(params ansi.Params, k KeyPressEvent) Event {
+ // Handle Kitty keyboard protocol
+ if len(params) > 2 && // We have at least 3 parameters
+ params[0].Param(1) == 1 && // The first parameter is 1 (defaults to 1)
+ params[1].HasMore() { // The second parameter is a subparameter (separated by a ":")
+ switch params[2].Param(1) { // The third parameter is the event type (defaults to 1)
+ case 2:
+ k.IsRepeat = true
+ case 3:
+ return KeyReleaseEvent(k)
+ }
+ }
+ return k
+}
+
+func parsePrimaryDevAttrs(params ansi.Params) Event {
+ // Primary Device Attributes
+ da1 := make(PrimaryDeviceAttributesEvent, len(params))
+ for i, p := range params {
+ if !p.HasMore() {
+ da1[i] = p.Param(0)
+ }
+ }
+ return da1
+}
+
+func parseSecondaryDevAttrs(params ansi.Params) Event {
+ // Secondary Device Attributes
+ da2 := make(SecondaryDeviceAttributesEvent, len(params))
+ for i, p := range params {
+ if !p.HasMore() {
+ da2[i] = p.Param(0)
+ }
+ }
+ return da2
+}
+
+func parseTertiaryDevAttrs(b []byte) Event {
+ // Tertiary Device Attributes
+ // The response is a 4-digit hexadecimal number.
+ bts, err := hex.DecodeString(string(b))
+ if err != nil {
+ return UnknownDcsEvent(fmt.Sprintf("\x1bP!|%s\x1b\\", b))
+ }
+ return TertiaryDeviceAttributesEvent(bts)
+}
+
+// Parse SGR-encoded mouse events; SGR extended mouse events. SGR mouse events
+// look like:
+//
+// ESC [ < Cb ; Cx ; Cy (M or m)
+//
+// where:
+//
+// Cb is the encoded button code
+// Cx is the x-coordinate of the mouse
+// Cy is the y-coordinate of the mouse
+// M is for button press, m is for button release
+//
+// https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Extended-coordinates
+func parseSGRMouseEvent(cmd ansi.Cmd, params ansi.Params) Event {
+ x, _, ok := params.Param(1, 1)
+ if !ok {
+ x = 1
+ }
+ y, _, ok := params.Param(2, 1)
+ if !ok {
+ y = 1
+ }
+ release := cmd.Final() == 'm'
+ b, _, _ := params.Param(0, 0)
+ mod, btn, _, isMotion := parseMouseButton(b)
+
+ // (1,1) is the upper left. We subtract 1 to normalize it to (0,0).
+ x--
+ y--
+
+ m := Mouse{X: x, Y: y, Button: btn, Mod: mod}
+
+ // Wheel buttons don't have release events
+ // Motion can be reported as a release event in some terminals (Windows Terminal)
+ if isWheel(m.Button) {
+ return MouseWheelEvent(m)
+ } else if !isMotion && release {
+ return MouseReleaseEvent(m)
+ } else if isMotion {
+ return MouseMotionEvent(m)
+ }
+ return MouseClickEvent(m)
+}
+
+const x10MouseByteOffset = 32
+
+// Parse X10-encoded mouse events; the simplest kind. The last release of X10
+// was December 1986, by the way. The original X10 mouse protocol limits the Cx
+// and Cy coordinates to 223 (=255-032).
+//
+// X10 mouse events look like:
+//
+// ESC [M Cb Cx Cy
+//
+// See: http://www.xfree86.org/current/ctlseqs.html#Mouse%20Tracking
+func parseX10MouseEvent(buf []byte) Event {
+ v := buf[3:6]
+ b := int(v[0])
+ if b >= x10MouseByteOffset {
+ // XXX: b < 32 should be impossible, but we're being defensive.
+ b -= x10MouseByteOffset
+ }
+
+ mod, btn, isRelease, isMotion := parseMouseButton(b)
+
+ // (1,1) is the upper left. We subtract 1 to normalize it to (0,0).
+ x := int(v[1]) - x10MouseByteOffset - 1
+ y := int(v[2]) - x10MouseByteOffset - 1
+
+ m := Mouse{X: x, Y: y, Button: btn, Mod: mod}
+ if isWheel(m.Button) {
+ return MouseWheelEvent(m)
+ } else if isMotion {
+ return MouseMotionEvent(m)
+ } else if isRelease {
+ return MouseReleaseEvent(m)
+ }
+ return MouseClickEvent(m)
+}
+
+// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Extended-coordinates
+func parseMouseButton(b int) (mod KeyMod, btn MouseButton, isRelease bool, isMotion bool) {
+ // mouse bit shifts
+ const (
+ bitShift = 0b0000_0100
+ bitAlt = 0b0000_1000
+ bitCtrl = 0b0001_0000
+ bitMotion = 0b0010_0000
+ bitWheel = 0b0100_0000
+ bitAdd = 0b1000_0000 // additional buttons 8-11
+
+ bitsMask = 0b0000_0011
+ )
+
+ // Modifiers
+ if b&bitAlt != 0 {
+ mod |= ModAlt
+ }
+ if b&bitCtrl != 0 {
+ mod |= ModCtrl
+ }
+ if b&bitShift != 0 {
+ mod |= ModShift
+ }
+
+ if b&bitAdd != 0 {
+ btn = MouseBackward + MouseButton(b&bitsMask)
+ } else if b&bitWheel != 0 {
+ btn = MouseWheelUp + MouseButton(b&bitsMask)
+ } else {
+ btn = MouseLeft + MouseButton(b&bitsMask)
+ // X10 reports a button release as 0b0000_0011 (3)
+ if b&bitsMask == bitsMask {
+ btn = MouseNone
+ isRelease = true
+ }
+ }
+
+ // Motion bit doesn't get reported for wheel events.
+ if b&bitMotion != 0 && !isWheel(btn) {
+ isMotion = true
+ }
+
+ return //nolint:nakedret
+}
+
+// isWheel returns true if the mouse event is a wheel event.
+func isWheel(btn MouseButton) bool {
+ return btn >= MouseWheelUp && btn <= MouseWheelRight
+}
+
+type shiftable interface {
+ ~uint | ~uint16 | ~uint32 | ~uint64
+}
+
+func shift[T shiftable](x T) T {
+ if x > 0xff {
+ x >>= 8
+ }
+ return x
+}
+
+func colorToHex(c color.Color) string {
+ if c == nil {
+ return ""
+ }
+ r, g, b, _ := c.RGBA()
+ return fmt.Sprintf("#%02x%02x%02x", shift(r), shift(g), shift(b))
+}
+
+func getMaxMin(a, b, c float64) (ma, mi float64) {
+ if a > b {
+ ma = a
+ mi = b
+ } else {
+ ma = b
+ mi = a
+ }
+ if c > ma {
+ ma = c
+ } else if c < mi {
+ mi = c
+ }
+ return ma, mi
+}
+
+func round(x float64) float64 {
+ return math.Round(x*1000) / 1000
+}
+
+// rgbToHSL converts an RGB triple to an HSL triple.
+func rgbToHSL(r, g, b uint8) (h, s, l float64) {
+ // convert uint32 pre-multiplied value to uint8
+ // The r,g,b values are divided by 255 to change the range from 0..255 to 0..1:
+ Rnot := float64(r) / 255
+ Gnot := float64(g) / 255
+ Bnot := float64(b) / 255
+ Cmax, Cmin := getMaxMin(Rnot, Gnot, Bnot)
+ Δ := Cmax - Cmin
+ // Lightness calculation:
+ l = (Cmax + Cmin) / 2
+ // Hue and Saturation Calculation:
+ if Δ == 0 {
+ h = 0
+ s = 0
+ } else {
+ switch Cmax {
+ case Rnot:
+ h = 60 * (math.Mod((Gnot-Bnot)/Δ, 6))
+ case Gnot:
+ h = 60 * (((Bnot - Rnot) / Δ) + 2)
+ case Bnot:
+ h = 60 * (((Rnot - Gnot) / Δ) + 4)
+ }
+ if h < 0 {
+ h += 360
+ }
+
+ s = Δ / (1 - math.Abs((2*l)-1))
+ }
+
+ return h, round(s), round(l)
+}
+
+// isDarkColor returns whether the given color is dark.
+func isDarkColor(c color.Color) bool {
+ if c == nil {
+ return true
+ }
+
+ r, g, b, _ := c.RGBA()
+ _, _, l := rgbToHSL(uint8(r>>8), uint8(g>>8), uint8(b>>8)) //nolint:gosec
+ return l < 0.5
+}
+
+func parseTermcap(data []byte) CapabilityEvent {
+ // XTGETTCAP
+ if len(data) == 0 {
+ return CapabilityEvent{""}
+ }
+
+ var tc strings.Builder
+ split := bytes.Split(data, []byte{';'})
+ for _, s := range split {
+ parts := bytes.SplitN(s, []byte{'='}, 2)
+ if len(parts) == 0 {
+ return CapabilityEvent{""}
+ }
+
+ name, err := hex.DecodeString(string(parts[0]))
+ if err != nil || len(name) == 0 {
+ continue
+ }
+
+ var value []byte
+ if len(parts) > 1 {
+ value, err = hex.DecodeString(string(parts[1]))
+ if err != nil {
+ continue
+ }
+ }
+
+ if tc.Len() > 0 {
+ tc.WriteByte(';')
+ }
+ tc.WriteString(string(name))
+ if len(value) > 0 {
+ tc.WriteByte('=')
+ tc.WriteString(string(value))
+ }
+ }
+
+ return CapabilityEvent{tc.String()}
+}
+
+// parseWin32InputKeyEvent converts a Windows Input Record Key Event into a
+// KeyPressEvent, KeyReleaseEvent, or MultiEvent including multiple of the
+// former type.
+// A special case is when the key is either part of VtInputMode which produces
+// vkc == 0, or when a key is a UTF-16 surrogate pair. In both of these cases,
+// we need to handle key encoding and properly parse the key event.
+func (p *EventDecoder) parseWin32InputKeyEvent(vkc uint16, _ uint16, r rune, keyDown bool, cks uint32, repeatCount uint16) (event Event) {
+ defer func() {
+ // Respect the repeat count.
+ if repeatCount > 1 {
+ var multi MultiEvent
+ for i := 0; i < int(repeatCount); i++ {
+ multi = append(multi, event)
+ }
+ event = multi
+ }
+ }()
+ defer func() {
+ if vkc != 0 {
+ p.lastCks = cks
+ }
+ }()
+
+ var key Key
+ switch {
+ case vkc == 0:
+ // This is either a UTF-16 encoded pair, or an escape sequence waiting
+ // to be decoded.
+ if keyDown {
+ return KeyPressEvent{Code: 0, BaseCode: r, Mod: translateControlKeyState(cks)}
+ }
+ return KeyReleaseEvent{Code: 0, BaseCode: r, Mod: translateControlKeyState(cks)}
+ case vkc == xwindows.VK_BACK:
+ key.BaseCode = KeyBackspace
+ case vkc == xwindows.VK_TAB:
+ key.BaseCode = KeyTab
+ case vkc == xwindows.VK_RETURN:
+ key.BaseCode = KeyEnter
+ case vkc == xwindows.VK_SHIFT:
+ //nolint:nestif
+ if cks&xwindows.SHIFT_PRESSED != 0 {
+ if cks&xwindows.ENHANCED_KEY != 0 {
+ key.BaseCode = KeyRightShift
+ } else {
+ key.BaseCode = KeyLeftShift
+ }
+ } else if p.lastCks&xwindows.SHIFT_PRESSED != 0 {
+ if p.lastCks&xwindows.ENHANCED_KEY != 0 {
+ key.BaseCode = KeyRightShift
+ } else {
+ key.BaseCode = KeyLeftShift
+ }
+ }
+ case vkc == xwindows.VK_CONTROL:
+ if cks&xwindows.LEFT_CTRL_PRESSED != 0 {
+ key.BaseCode = KeyLeftCtrl
+ } else if cks&xwindows.RIGHT_CTRL_PRESSED != 0 {
+ key.BaseCode = KeyRightCtrl
+ } else if p.lastCks&xwindows.LEFT_CTRL_PRESSED != 0 {
+ key.BaseCode = KeyLeftCtrl
+ } else if p.lastCks&xwindows.RIGHT_CTRL_PRESSED != 0 {
+ key.BaseCode = KeyRightCtrl
+ }
+ case vkc == xwindows.VK_MENU:
+ if cks&xwindows.LEFT_ALT_PRESSED != 0 {
+ key.BaseCode = KeyLeftAlt
+ } else if cks&xwindows.RIGHT_ALT_PRESSED != 0 {
+ key.BaseCode = KeyRightAlt
+ } else if p.lastCks&xwindows.LEFT_ALT_PRESSED != 0 {
+ key.BaseCode = KeyLeftAlt
+ } else if p.lastCks&xwindows.RIGHT_ALT_PRESSED != 0 {
+ key.BaseCode = KeyRightAlt
+ }
+ case vkc == xwindows.VK_PAUSE:
+ key.BaseCode = KeyPause
+ case vkc == xwindows.VK_CAPITAL:
+ key.BaseCode = KeyCapsLock
+ case vkc == xwindows.VK_ESCAPE:
+ key.BaseCode = KeyEscape
+ case vkc == xwindows.VK_SPACE:
+ key.BaseCode = KeySpace
+ case vkc == xwindows.VK_PRIOR:
+ key.BaseCode = KeyPgUp
+ case vkc == xwindows.VK_NEXT:
+ key.BaseCode = KeyPgDown
+ case vkc == xwindows.VK_END:
+ key.BaseCode = KeyEnd
+ case vkc == xwindows.VK_HOME:
+ key.BaseCode = KeyHome
+ case vkc == xwindows.VK_LEFT:
+ key.BaseCode = KeyLeft
+ case vkc == xwindows.VK_UP:
+ key.BaseCode = KeyUp
+ case vkc == xwindows.VK_RIGHT:
+ key.BaseCode = KeyRight
+ case vkc == xwindows.VK_DOWN:
+ key.BaseCode = KeyDown
+ case vkc == xwindows.VK_SELECT:
+ key.BaseCode = KeySelect
+ case vkc == xwindows.VK_SNAPSHOT:
+ key.BaseCode = KeyPrintScreen
+ case vkc == xwindows.VK_INSERT:
+ key.BaseCode = KeyInsert
+ case vkc == xwindows.VK_DELETE:
+ key.BaseCode = KeyDelete
+ case vkc >= '0' && vkc <= '9':
+ key.BaseCode = rune(vkc)
+ case vkc >= 'A' && vkc <= 'Z':
+ // Convert to lowercase.
+ key.BaseCode = rune(vkc) + 32
+ case vkc == xwindows.VK_LWIN:
+ key.BaseCode = KeyLeftSuper
+ case vkc == xwindows.VK_RWIN:
+ key.BaseCode = KeyRightSuper
+ case vkc == xwindows.VK_APPS:
+ key.BaseCode = KeyMenu
+ case vkc >= xwindows.VK_NUMPAD0 && vkc <= xwindows.VK_NUMPAD9:
+ key.BaseCode = rune(vkc-xwindows.VK_NUMPAD0) + KeyKp0
+ key.Text = string('0' + (rune(vkc) - xwindows.VK_NUMPAD0))
+ case vkc == xwindows.VK_MULTIPLY:
+ key.BaseCode = KeyKpMultiply
+ key.Text = "*"
+ case vkc == xwindows.VK_ADD:
+ key.BaseCode = KeyKpPlus
+ key.Text = "+"
+ case vkc == xwindows.VK_SEPARATOR:
+ key.BaseCode = KeyKpComma
+ key.Text = ","
+ case vkc == xwindows.VK_SUBTRACT:
+ key.BaseCode = KeyKpMinus
+ key.Text = "-"
+ case vkc == xwindows.VK_DECIMAL:
+ key.BaseCode = KeyKpDecimal
+ key.Text = "."
+ case vkc == xwindows.VK_DIVIDE:
+ key.BaseCode = KeyKpDivide
+ key.Text = "/"
+ case vkc >= xwindows.VK_F1 && vkc <= xwindows.VK_F24:
+ key.BaseCode = rune(vkc-xwindows.VK_F1) + KeyF1
+ case vkc == xwindows.VK_NUMLOCK:
+ key.BaseCode = KeyNumLock
+ case vkc == xwindows.VK_SCROLL:
+ key.BaseCode = KeyScrollLock
+ case vkc == xwindows.VK_LSHIFT:
+ key.BaseCode = KeyLeftShift
+ case vkc == xwindows.VK_RSHIFT:
+ key.BaseCode = KeyRightShift
+ case vkc == xwindows.VK_LCONTROL:
+ key.BaseCode = KeyLeftCtrl
+ case vkc == xwindows.VK_RCONTROL:
+ key.BaseCode = KeyRightCtrl
+ case vkc == xwindows.VK_LMENU:
+ key.BaseCode = KeyLeftAlt
+ case vkc == xwindows.VK_RMENU:
+ key.BaseCode = KeyRightAlt
+ case vkc == xwindows.VK_VOLUME_MUTE:
+ key.BaseCode = KeyMute
+ case vkc == xwindows.VK_VOLUME_DOWN:
+ key.BaseCode = KeyLowerVol
+ case vkc == xwindows.VK_VOLUME_UP:
+ key.BaseCode = KeyRaiseVol
+ case vkc == xwindows.VK_MEDIA_NEXT_TRACK:
+ key.BaseCode = KeyMediaNext
+ case vkc == xwindows.VK_MEDIA_PREV_TRACK:
+ key.BaseCode = KeyMediaPrev
+ case vkc == xwindows.VK_MEDIA_STOP:
+ key.BaseCode = KeyMediaStop
+ case vkc == xwindows.VK_MEDIA_PLAY_PAUSE:
+ key.BaseCode = KeyMediaPlayPause
+ case vkc == xwindows.VK_OEM_1:
+ key.BaseCode = ';'
+ case vkc == xwindows.VK_OEM_PLUS:
+ key.BaseCode = '+'
+ case vkc == xwindows.VK_OEM_COMMA:
+ key.BaseCode = ','
+ case vkc == xwindows.VK_OEM_MINUS:
+ key.BaseCode = '-'
+ case vkc == xwindows.VK_OEM_PERIOD:
+ key.BaseCode = '.'
+ case vkc == xwindows.VK_OEM_2:
+ key.BaseCode = '/'
+ case vkc == xwindows.VK_OEM_3:
+ key.BaseCode = '`'
+ case vkc == xwindows.VK_OEM_4:
+ key.BaseCode = '['
+ case vkc == xwindows.VK_OEM_5:
+ key.BaseCode = '\\'
+ case vkc == xwindows.VK_OEM_6:
+ key.BaseCode = ']'
+ case vkc == xwindows.VK_OEM_7:
+ key.BaseCode = '\''
+ }
+
+ // AltGr is left ctrl + right alt. On non-US keyboards, this is used to type
+ // special characters and produce printable events.
+ // XXX: Should this be a KeyMod?
+ const altGrPressed = xwindows.LEFT_CTRL_PRESSED | xwindows.RIGHT_ALT_PRESSED
+ altGr := cks&altGrPressed == altGrPressed
+
+ // Remove these lock keys from the control key state from now on.
+ cks &^= xwindows.NUMLOCK_ON
+ cks &^= xwindows.SCROLLLOCK_ON
+ key.Code = key.BaseCode
+ if !unicode.IsControl(r) {
+ key.Code = r
+ if unicode.IsPrint(key.Code) && (cks == 0 || // no modifiers pressed
+ cks == xwindows.SHIFT_PRESSED || // shift pressed
+ cks == xwindows.CAPSLOCK_ON || // caps lock on
+ cks == (xwindows.SHIFT_PRESSED|xwindows.CAPSLOCK_ON) || // Shift + caps lock pressed
+ altGr) { // AltGr pressed
+ // If the control key state is 0, shift is pressed, or caps lock
+ // then the key event is a printable event i.e. [text] is not empty.
+ key.Text = string(key.Code)
+ }
+ }
+
+ key.Mod = translateControlKeyState(cks)
+ key = ensureKeyCase(key, cks)
+ if keyDown {
+ return KeyPressEvent(key)
+ }
+
+ return KeyReleaseEvent(key)
+}
+
+// ensureKeyCase ensures that the key's text is in the correct case based on the
+// control key state.
+func ensureKeyCase(key Key, cks uint32) Key {
+ if len(key.Text) == 0 {
+ return key
+ }
+
+ hasShift := cks&xwindows.SHIFT_PRESSED != 0
+ hasCaps := cks&xwindows.CAPSLOCK_ON != 0
+ if hasShift || hasCaps {
+ if unicode.IsLower(key.Code) {
+ key.ShiftedCode = unicode.ToUpper(key.Code)
+ key.Text = string(key.ShiftedCode)
+ }
+ } else {
+ if unicode.IsUpper(key.Code) {
+ key.ShiftedCode = unicode.ToLower(key.Code)
+ key.Text = string(key.ShiftedCode)
+ }
+ }
+
+ return key
+}
+
+// translateControlKeyState translates the control key state from the Windows
+// Console API into a Mod bitmask.
+func translateControlKeyState(cks uint32) (m KeyMod) {
+ if cks&xwindows.LEFT_CTRL_PRESSED != 0 || cks&xwindows.RIGHT_CTRL_PRESSED != 0 {
+ m |= ModCtrl
+ }
+ if cks&xwindows.LEFT_ALT_PRESSED != 0 || cks&xwindows.RIGHT_ALT_PRESSED != 0 {
+ m |= ModAlt
+ }
+ if cks&xwindows.SHIFT_PRESSED != 0 {
+ m |= ModShift
+ }
+ if cks&xwindows.CAPSLOCK_ON != 0 {
+ m |= ModCapsLock
+ }
+ if cks&xwindows.NUMLOCK_ON != 0 {
+ m |= ModNumLock
+ }
+ if cks&xwindows.SCROLLLOCK_ON != 0 {
+ m |= ModScrollLock
+ }
+ return
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/doc.go b/vendor/github.com/charmbracelet/ultraviolet/doc.go
new file mode 100644
index 000000000..af352053c
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/doc.go
@@ -0,0 +1,3 @@
+// Package uv (Ultraviolet) is a library for creating terminal-based user
+// interfaces in Go.
+package uv
diff --git a/vendor/github.com/charmbracelet/ultraviolet/environ.go b/vendor/github.com/charmbracelet/ultraviolet/environ.go
new file mode 100644
index 000000000..9622b607a
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/environ.go
@@ -0,0 +1,32 @@
+package uv
+
+import (
+ "strings"
+)
+
+// Environ is a slice of strings that represents the environment variables of
+// the program.
+type Environ []string
+
+// Getenv returns the value of the environment variable named by the key. If
+// the variable is not present in the environment, the value returned will be
+// the empty string.
+func (p Environ) Getenv(key string) (v string) {
+ v, _ = p.LookupEnv(key)
+ return
+}
+
+// LookupEnv retrieves the value of the environment variable named by the key.
+// If the variable is present in the environment the value (which may be empty)
+// is returned and the boolean is true. Otherwise the returned value will be
+// empty and the boolean will be false.
+func (p Environ) LookupEnv(key string) (s string, v bool) {
+ for i := len(p) - 1; i >= 0; i-- {
+ if strings.HasPrefix(p[i], key+"=") {
+ s = strings.TrimPrefix(p[i], key+"=")
+ v = true
+ break
+ }
+ }
+ return
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/event.go b/vendor/github.com/charmbracelet/ultraviolet/event.go
new file mode 100644
index 000000000..bf48d147c
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/event.go
@@ -0,0 +1,567 @@
+package uv
+
+import (
+ "context"
+ "fmt"
+ "image"
+ "image/color"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/charmbracelet/x/ansi/kitty"
+)
+
+// Event represents an input event that can be received from an input source.
+type Event interface{}
+
+// EventStreamer is an interface that defines a method to stream events from an
+// input source. It takes a context and a channel to send events to. The
+// streamer should block until the context is done or an error occurs. The
+// channel should never be closed by the streamer, as it is the responsibility
+// of the consumer to close it when done.
+type EventStreamer interface {
+ StreamEvents(ctx context.Context, ch chan<- Event) error
+}
+
+// UnknownEvent represents an unknown event.
+type UnknownEvent string
+
+// String returns a string representation of the unknown event.
+func (e UnknownEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownCsiEvent represents an unknown CSI (Control Sequence Introducer) event.
+type UnknownCsiEvent string
+
+// String returns a string representation of the unknown CSI event.
+func (e UnknownCsiEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownSs3Event represents an unknown SS3 (Single Shift 3) event.
+type UnknownSs3Event string
+
+// String returns a string representation of the unknown SS3 event.
+func (e UnknownSs3Event) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownOscEvent represents an unknown OSC (Operating System Command) event.
+type UnknownOscEvent string
+
+// String returns a string representation of the unknown OSC event.
+func (e UnknownOscEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownDcsEvent represents an unknown DCS (Device Control String) event.
+type UnknownDcsEvent string
+
+// String returns a string representation of the unknown DCS event.
+func (e UnknownDcsEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownSosEvent represents an unknown SOS (Start of String) event.
+type UnknownSosEvent string
+
+// String returns a string representation of the unknown SOS event.
+func (e UnknownSosEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownPmEvent represents an unknown PM (Privacy Message) event.
+type UnknownPmEvent string
+
+// String returns a string representation of the unknown PM event.
+func (e UnknownPmEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// UnknownApcEvent represents an unknown APC (Application Program Command) event.
+type UnknownApcEvent string
+
+// String returns a string representation of the unknown APC event.
+func (e UnknownApcEvent) String() string {
+ return fmt.Sprintf("%q", string(e))
+}
+
+// MultiEvent represents multiple messages event.
+type MultiEvent []Event
+
+// String returns a string representation of the multiple messages event.
+func (e MultiEvent) String() string {
+ var sb strings.Builder
+ for _, ev := range e {
+ sb.WriteString(fmt.Sprintf("%v\n", ev))
+ }
+ return sb.String()
+}
+
+// Size represents the size of the terminal window.
+type Size struct {
+ Width int
+ Height int
+}
+
+// Bounds returns the bounds corresponding to the size.
+func (s Size) Bounds() Rectangle {
+ return Rectangle{
+ Min: image.Point{X: 0, Y: 0},
+ Max: image.Point{X: s.Width, Y: s.Height},
+ }
+}
+
+// WindowSizeEvent represents the window size in cells.
+type WindowSizeEvent Size
+
+// Bounds returns the bounds corresponding to the size.
+func (s WindowSizeEvent) Bounds() Rectangle {
+ return Size(s).Bounds()
+}
+
+// PixelSizeEvent represents the window size in pixels.
+type PixelSizeEvent Size
+
+// Bounds returns the bounds corresponding to the size.
+func (s PixelSizeEvent) Bounds() Rectangle {
+ return Size(s).Bounds()
+}
+
+// CellSizeEvent represents the cell size in pixels.
+type CellSizeEvent Size
+
+// Bounds returns the bounds corresponding to the size.
+func (s CellSizeEvent) Bounds() Rectangle {
+ return Size(s).Bounds()
+}
+
+// KeyPressEvent represents a key press event.
+type KeyPressEvent Key
+
+// MatchString returns true if the [Key] matches one of the given strings.
+//
+// A string can be a key name like "enter", "tab", "a", or a printable
+// character like "1" or " ". It can also have combinations of modifiers like
+// "ctrl+a", "shift+enter", "alt+tab", "ctrl+shift+enter", etc.
+func (k KeyPressEvent) MatchString(s ...string) bool {
+ return Key(k).MatchString(s...)
+}
+
+// String implements [fmt.Stringer] and is quite useful for matching key
+// events. For details, on what this returns see [Key.String].
+func (k KeyPressEvent) String() string {
+ return Key(k).String()
+}
+
+// Keystroke returns the keystroke representation of the [Key]. While less type
+// safe than looking at the individual fields, it will usually be more
+// convenient and readable to use this method when matching against keys.
+//
+// Note that modifier keys are always printed in the following order:
+// - ctrl
+// - alt
+// - shift
+// - meta
+// - hyper
+// - super
+//
+// For example, you'll always see "ctrl+shift+alt+a" and never
+// "shift+ctrl+alt+a".
+func (k KeyPressEvent) Keystroke() string {
+ return Key(k).Keystroke()
+}
+
+// Key returns the underlying key event. This is a syntactic sugar for casting
+// the key event to a [Key].
+func (k KeyPressEvent) Key() Key {
+ return Key(k)
+}
+
+// KeyReleaseEvent represents a key release event.
+type KeyReleaseEvent Key
+
+// MatchString returns true if the [Key] matches one of the given strings.
+//
+// A string can be a key name like "enter", "tab", "a", or a printable
+// character like "1" or " ". It can also have combinations of modifiers like
+// "ctrl+a", "shift+enter", "alt+tab", "ctrl+shift+enter", etc.
+func (k KeyReleaseEvent) MatchString(s ...string) bool {
+ return Key(k).MatchString(s...)
+}
+
+// String implements [fmt.Stringer] and is quite useful for matching key
+// events. For details, on what this returns see [Key.String].
+func (k KeyReleaseEvent) String() string {
+ return Key(k).String()
+}
+
+// Keystroke returns the keystroke representation of the [Key]. While less type
+// safe than looking at the individual fields, it will usually be more
+// convenient and readable to use this method when matching against keys.
+//
+// Note that modifier keys are always printed in the following order:
+// - ctrl
+// - alt
+// - shift
+// - meta
+// - hyper
+// - super
+//
+// For example, you'll always see "ctrl+shift+alt+a" and never
+// "shift+ctrl+alt+a".
+func (k KeyReleaseEvent) Keystroke() string {
+ return Key(k).Keystroke()
+}
+
+// Key returns the underlying key event. This is a convenience method and
+// syntactic sugar to satisfy the [KeyEvent] interface, and cast the key event to
+// [Key].
+func (k KeyReleaseEvent) Key() Key {
+ return Key(k)
+}
+
+// KeyEvent represents a key event. This can be either a key press or a key
+// release event.
+type KeyEvent interface {
+ fmt.Stringer
+
+ // Key returns the underlying key event.
+ Key() Key
+}
+
+// MouseEvent represents a mouse message. This is a generic mouse message that
+// can represent any kind of mouse event.
+type MouseEvent interface {
+ fmt.Stringer
+
+ // Mouse returns the underlying mouse event.
+ Mouse() Mouse
+}
+
+// MouseClickEvent represents a mouse button click event.
+type MouseClickEvent Mouse
+
+// String returns a string representation of the mouse click event.
+func (e MouseClickEvent) String() string {
+ return Mouse(e).String()
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseEvent] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseClickEvent) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// MouseReleaseEvent represents a mouse button release event.
+type MouseReleaseEvent Mouse
+
+// String returns a string representation of the mouse release event.
+func (e MouseReleaseEvent) String() string {
+ return Mouse(e).String()
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseEvent] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseReleaseEvent) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// MouseWheelEvent represents a mouse wheel message event.
+type MouseWheelEvent Mouse
+
+// String returns a string representation of the mouse wheel event.
+func (e MouseWheelEvent) String() string {
+ return Mouse(e).String()
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseEvent] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseWheelEvent) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// MouseMotionEvent represents a mouse motion event.
+type MouseMotionEvent Mouse
+
+// String returns a string representation of the mouse motion event.
+func (e MouseMotionEvent) String() string {
+ m := Mouse(e)
+ if m.Button != 0 {
+ return m.String() + "+motion"
+ }
+ return m.String() + "motion"
+}
+
+// Mouse returns the underlying mouse event. This is a convenience method and
+// syntactic sugar to satisfy the [MouseEvent] interface, and cast the mouse
+// event to [Mouse].
+func (e MouseMotionEvent) Mouse() Mouse {
+ return Mouse(e)
+}
+
+// CursorPositionEvent represents a cursor position event. Where X is the
+// zero-based column and Y is the zero-based row.
+type CursorPositionEvent struct {
+ X, Y int
+}
+
+// FocusEvent represents a terminal focus event.
+// This occurs when the terminal gains focus.
+type FocusEvent struct{}
+
+// BlurEvent represents a terminal blur event.
+// This occurs when the terminal loses focus.
+type BlurEvent struct{}
+
+// DarkColorSchemeEvent is sent when the operating system is using a dark color
+// scheme. This is typically used to notify applications of the current or new
+// system color scheme.
+type DarkColorSchemeEvent struct{}
+
+// LightColorSchemeEvent is sent when the operating system is using a light color
+// scheme. This is typically used to notify applications of the current or new
+// system color scheme.
+type LightColorSchemeEvent struct{}
+
+// PasteEvent is an message that is emitted when a terminal receives pasted text
+// using bracketed-paste.
+type PasteEvent struct {
+ // Content is the pasted text content.
+ Content string
+}
+
+// String returns the pasted content as a string.
+func (e PasteEvent) String() string {
+ return e.Content
+}
+
+// PasteStartEvent is an message that is emitted when the terminal starts the
+// bracketed-paste text.
+type PasteStartEvent struct{}
+
+// PasteEndEvent is an message that is emitted when the terminal ends the
+// bracketed-paste text.
+type PasteEndEvent struct{}
+
+// TerminalVersionEvent is a message that represents the terminal version.
+type TerminalVersionEvent struct {
+ Name string
+}
+
+// String returns the terminal version as a string.
+func (e TerminalVersionEvent) String() string {
+ return e.Name
+}
+
+// ModifyOtherKeysEvent represents a modifyOtherKeys event.
+//
+// 0: disable
+// 1: enable mode 1
+// 2: enable mode 2
+//
+// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Functions-using-CSI-_-ordered-by-the-final-character_s_
+// See: https://invisible-island.net/xterm/manpage/xterm.html#VT100-Widget-Resources:modifyOtherKeys
+type ModifyOtherKeysEvent struct {
+ Mode int
+}
+
+// KittyGraphicsEvent represents a Kitty Graphics response event.
+//
+// See https://sw.kovidgoyal.net/kitty/graphics-protocol/
+type KittyGraphicsEvent struct {
+ Options kitty.Options
+ Payload []byte
+}
+
+// KeyboardEnhancementsEvent represents a keyboard enhancements report event.
+type KeyboardEnhancementsEvent struct {
+ // Flags are the Kitty Keyboard Enhancement flags.
+ //
+ // Bit values:
+ //
+ // 00000001: Disambiguate escape codes
+ // 00000010: Report event types
+ // 00000100: Report alternate keys
+ // 00001000: Report all keys as escape codes
+ // 00010000: Report associated text
+ //
+ // See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/#keyboard-enhancements
+ Flags int
+}
+
+// Contains reports whether m contains the given enhancements.
+func (e KeyboardEnhancementsEvent) Contains(enhancements int) bool {
+ return e.Flags&enhancements == enhancements
+}
+
+// SupportsKeyDisambiguation returns whether the terminal supports reporting
+// disambiguous keys as escape codes.
+func (e KeyboardEnhancementsEvent) SupportsKeyDisambiguation() bool {
+ return e.Flags&ansi.KittyDisambiguateEscapeCodes != 0
+}
+
+// SupportsKeyReleases returns whether the terminal supports key release
+// events.
+func (e KeyboardEnhancementsEvent) SupportsKeyReleases() bool {
+ return e.Flags&ansi.KittyReportEventTypes != 0
+}
+
+// SupportsUniformKeyLayout returns whether the terminal supports reporting key
+// events as though they were on a PC-101 layout.
+func (e KeyboardEnhancementsEvent) SupportsUniformKeyLayout() bool {
+ return e.SupportsKeyDisambiguation() &&
+ e.Flags&ansi.KittyReportAlternateKeys != 0 &&
+ e.Flags&ansi.KittyReportAllKeysAsEscapeCodes != 0
+}
+
+// PrimaryDeviceAttributesEvent is an event that represents the terminal
+// primary device attributes.
+//
+// Common attributes include:
+// - 1 132 columns
+// - 2 Printer port
+// - 4 Sixel
+// - 6 Selective erase
+// - 7 Soft character set (DRCS)
+// - 8 User-defined keys (UDKs)
+// - 9 National replacement character sets (NRCS) (International terminal only)
+// - 12 Yugoslavian (SCS)
+// - 15 Technical character set
+// - 18 Windowing capability
+// - 21 Horizontal scrolling
+// - 23 Greek
+// - 24 Turkish
+// - 42 ISO Latin-2 character set
+// - 44 PCTerm
+// - 45 Soft key map
+// - 46 ASCII emulation
+//
+// See [ansi.PrimaryDeviceAttributes] for more details.
+type PrimaryDeviceAttributesEvent []int
+
+// SecondaryDeviceAttributesEvent is an event that represents the terminal
+// secondary device attributes.
+//
+// See [ansi.SecondaryDeviceAttributes] for more details.
+type SecondaryDeviceAttributesEvent []int
+
+// TertiaryDeviceAttributesEvent is an event that represents the terminal
+// tertiary device attributes.
+//
+// See [ansi.TertiaryDeviceAttributes] for more details.
+type TertiaryDeviceAttributesEvent string
+
+// ModeReportEvent is a message that represents a mode report event (DECRPM).
+//
+// See: https://vt100.net/docs/vt510-rm/DECRPM.html
+type ModeReportEvent struct {
+ // Mode is the mode number.
+ Mode ansi.Mode
+
+ // Value is the mode value.
+ Value ansi.ModeSetting
+}
+
+// ForegroundColorEvent represents a foreground color event. This event is
+// emitted when the terminal requests the terminal foreground color using
+// [ansi.RequestForegroundColor].
+type ForegroundColorEvent struct{ color.Color }
+
+// String returns the hex representation of the color.
+func (e ForegroundColorEvent) String() string {
+ return colorToHex(e.Color)
+}
+
+// IsDark returns whether the color is dark.
+func (e ForegroundColorEvent) IsDark() bool {
+ return isDarkColor(e.Color)
+}
+
+// BackgroundColorEvent represents a background color event. This event is
+// emitted when the terminal requests the terminal background color using
+// [ansi.RequestBackgroundColor].
+type BackgroundColorEvent struct{ color.Color }
+
+// String returns the hex representation of the color.
+func (e BackgroundColorEvent) String() string {
+ return colorToHex(e)
+}
+
+// IsDark returns whether the color is dark.
+func (e BackgroundColorEvent) IsDark() bool {
+ return isDarkColor(e.Color)
+}
+
+// CursorColorEvent represents a cursor color change event. This event is
+// emitted when the program requests the terminal cursor color using
+// [ansi.RequestCursorColor].
+type CursorColorEvent struct{ color.Color }
+
+// String returns the hex representation of the color.
+func (e CursorColorEvent) String() string {
+ return colorToHex(e)
+}
+
+// IsDark returns whether the color is dark.
+func (e CursorColorEvent) IsDark() bool {
+ return isDarkColor(e)
+}
+
+// WindowOpEvent is a window operation (XTWINOPS) report event. This is used to
+// report various window operations such as reporting the window size or cell
+// size.
+type WindowOpEvent struct {
+ Op int
+ Args []int
+}
+
+// CapabilityEvent represents a Termcap/Terminfo response event. Termcap
+// responses are generated by the terminal in response to RequestTermcap
+// (XTGETTCAP) requests.
+//
+// See: https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Operating-System-Commands
+type CapabilityEvent struct {
+ Content string
+}
+
+// String returns the capability content.
+func (e CapabilityEvent) String() string {
+ return e.Content
+}
+
+// ClipboardSelection represents a clipboard selection. The most common
+// clipboard selections are "system" and "primary" and selections.
+type ClipboardSelection = byte
+
+// Clipboard selections.
+const (
+ SystemClipboard ClipboardSelection = ansi.SystemClipboard
+ PrimaryClipboard ClipboardSelection = ansi.PrimaryClipboard
+)
+
+// ClipboardEvent is a clipboard read message event. This message is emitted when
+// a terminal receives an OSC52 clipboard read message event.
+type ClipboardEvent struct {
+ Content string
+ Selection ClipboardSelection
+}
+
+// String returns the string representation of the clipboard message.
+func (e ClipboardEvent) String() string {
+ return e.Content
+}
+
+// Clipboard returns the clipboard selection. This can be either
+// [SystemClipboard] 'c' or [PrimaryClipboard] 'p'.
+func (e ClipboardEvent) Clipboard() ClipboardSelection {
+ return e.Selection
+}
+
+// ignoredEvent represents a sequence event that is ignored by the terminal
+// reader. This is used to ignore certain sequences that can be canceled.
+type ignoredEvent string
diff --git a/vendor/github.com/charmbracelet/ultraviolet/key.go b/vendor/github.com/charmbracelet/ultraviolet/key.go
new file mode 100644
index 000000000..f3b5f6a57
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/key.go
@@ -0,0 +1,762 @@
+package uv
+
+import (
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// KeyMod represents modifier keys.
+type KeyMod int
+
+// Modifier keys.
+const (
+ ModShift KeyMod = 1 << iota
+ ModAlt
+ ModCtrl
+ ModMeta
+
+ // These modifiers are used with the Kitty protocol.
+ // XXX: Meta and Super are swapped in the Kitty protocol,
+ // this is to preserve compatibility with XTerm modifiers.
+
+ ModHyper
+ ModSuper // Windows/Command keys
+
+ // These are key lock states.
+
+ ModCapsLock
+ ModNumLock
+ ModScrollLock // Defined in Windows API only
+)
+
+// Contains reports whether m contains the given modifiers.
+//
+// Example:
+//
+// m := ModAlt | ModCtrl
+// m.Contains(ModCtrl) // true
+// m.Contains(ModAlt | ModCtrl) // true
+// m.Contains(ModAlt | ModCtrl | ModShift) // false
+func (m KeyMod) Contains(mods KeyMod) bool {
+ return m&mods == mods
+}
+
+const (
+ // KeyExtended is a special key code used to signify that a key event
+ // contains multiple runes.
+ KeyExtended = unicode.MaxRune + 1
+)
+
+// Special key symbols.
+const (
+
+ // Special keys.
+
+ KeyUp rune = KeyExtended + iota + 1
+ KeyDown
+ KeyRight
+ KeyLeft
+ KeyBegin
+ KeyFind
+ KeyInsert
+ KeyDelete
+ KeySelect
+ KeyPgUp
+ KeyPgDown
+ KeyHome
+ KeyEnd
+
+ // Keypad keys.
+
+ KeyKpEnter
+ KeyKpEqual
+ KeyKpMultiply
+ KeyKpPlus
+ KeyKpComma
+ KeyKpMinus
+ KeyKpDecimal
+ KeyKpDivide
+ KeyKp0
+ KeyKp1
+ KeyKp2
+ KeyKp3
+ KeyKp4
+ KeyKp5
+ KeyKp6
+ KeyKp7
+ KeyKp8
+ KeyKp9
+
+ //nolint:godox
+ // The following are keys defined in the Kitty keyboard protocol.
+ // TODO: Investigate the names of these keys.
+
+ KeyKpSep
+ KeyKpUp
+ KeyKpDown
+ KeyKpLeft
+ KeyKpRight
+ KeyKpPgUp
+ KeyKpPgDown
+ KeyKpHome
+ KeyKpEnd
+ KeyKpInsert
+ KeyKpDelete
+ KeyKpBegin
+
+ // Function keys.
+
+ KeyF1
+ KeyF2
+ KeyF3
+ KeyF4
+ KeyF5
+ KeyF6
+ KeyF7
+ KeyF8
+ KeyF9
+ KeyF10
+ KeyF11
+ KeyF12
+ KeyF13
+ KeyF14
+ KeyF15
+ KeyF16
+ KeyF17
+ KeyF18
+ KeyF19
+ KeyF20
+ KeyF21
+ KeyF22
+ KeyF23
+ KeyF24
+ KeyF25
+ KeyF26
+ KeyF27
+ KeyF28
+ KeyF29
+ KeyF30
+ KeyF31
+ KeyF32
+ KeyF33
+ KeyF34
+ KeyF35
+ KeyF36
+ KeyF37
+ KeyF38
+ KeyF39
+ KeyF40
+ KeyF41
+ KeyF42
+ KeyF43
+ KeyF44
+ KeyF45
+ KeyF46
+ KeyF47
+ KeyF48
+ KeyF49
+ KeyF50
+ KeyF51
+ KeyF52
+ KeyF53
+ KeyF54
+ KeyF55
+ KeyF56
+ KeyF57
+ KeyF58
+ KeyF59
+ KeyF60
+ KeyF61
+ KeyF62
+ KeyF63
+
+ //nolint:godox
+ // The following are keys defined in the Kitty keyboard protocol.
+ // TODO: Investigate the names of these keys.
+
+ KeyCapsLock
+ KeyScrollLock
+ KeyNumLock
+ KeyPrintScreen
+ KeyPause
+ KeyMenu
+
+ KeyMediaPlay
+ KeyMediaPause
+ KeyMediaPlayPause
+ KeyMediaReverse
+ KeyMediaStop
+ KeyMediaFastForward
+ KeyMediaRewind
+ KeyMediaNext
+ KeyMediaPrev
+ KeyMediaRecord
+
+ KeyLowerVol
+ KeyRaiseVol
+ KeyMute
+
+ KeyLeftShift
+ KeyLeftAlt
+ KeyLeftCtrl
+ KeyLeftSuper
+ KeyLeftHyper
+ KeyLeftMeta
+ KeyRightShift
+ KeyRightAlt
+ KeyRightCtrl
+ KeyRightSuper
+ KeyRightHyper
+ KeyRightMeta
+ KeyIsoLevel3Shift
+ KeyIsoLevel5Shift
+
+ // Special names in C0.
+
+ KeyBackspace = rune(ansi.DEL)
+ KeyTab = rune(ansi.HT)
+ KeyEnter = rune(ansi.CR)
+ KeyReturn = KeyEnter
+ KeyEscape = rune(ansi.ESC)
+ KeyEsc = KeyEscape
+
+ // Special names in G0.
+
+ KeySpace = rune(ansi.SP)
+)
+
+// Key represents a Key press or release event. It contains information about
+// the Key pressed, like the runes, the type of Key, and the modifiers pressed.
+// There are a couple general patterns you could use to check for key presses
+// or releases:
+//
+// // Switch on the string representation of the key (shorter)
+// switch ev := ev.(type) {
+// case KeyPressEvent:
+// switch ev.String() {
+// case "enter":
+// fmt.Println("you pressed enter!")
+// case "a":
+// fmt.Println("you pressed a!")
+// }
+// }
+//
+// // Switch on the key type (more foolproof)
+// switch ev := ev.(type) {
+// case KeyEvent:
+// // catch both KeyPressEvent and KeyReleaseEvent
+// switch key := ev.Key(); key.Code {
+// case KeyEnter:
+// fmt.Println("you pressed enter!")
+// default:
+// switch key.Text {
+// case "a":
+// fmt.Println("you pressed a!")
+// }
+// }
+// }
+//
+// Note that [Key.Text] will be empty for special keys like [KeyEnter],
+// [KeyTab], and for keys that don't represent printable characters like key
+// combos with modifier keys. In other words, [Key.Text] is populated only for
+// keys that represent printable characters shifted or unshifted (like 'a',
+// 'A', '1', '!', etc.).
+type Key struct {
+ // Text contains the actual characters received. This usually the same as
+ // [Key.Code]. When [Key.Text] is non-empty, it indicates that the key
+ // pressed represents printable character(s).
+ Text string
+
+ // Mod represents modifier keys, like [ModCtrl], [ModAlt], and so on.
+ Mod KeyMod
+
+ // Code represents the key pressed. This is usually a special key like
+ // [KeyTab], [KeyEnter], [KeyF1], or a printable character like 'a'.
+ Code rune
+
+ // ShiftedCode is the actual, shifted key pressed by the user. For example,
+ // if the user presses shift+a, or caps lock is on, [Key.ShiftedCode] will
+ // be 'A' and [Key.Code] will be 'a'.
+ //
+ // In the case of non-latin keyboards, like Arabic, [Key.ShiftedCode] is the
+ // unshifted key on the keyboard.
+ //
+ // This is only available with the Kitty Keyboard Protocol or the Windows
+ // Console API.
+ ShiftedCode rune
+
+ // BaseCode is the key pressed according to the standard PC-101 key layout.
+ // On international keyboards, this is the key that would be pressed if the
+ // keyboard was set to US PC-101 layout.
+ //
+ // For example, if the user presses 'q' on a French AZERTY keyboard,
+ // [Key.BaseCode] will be 'q'.
+ //
+ // This is only available with the Kitty Keyboard Protocol or the Windows
+ // Console API.
+ BaseCode rune
+
+ // IsRepeat indicates whether the key is being held down and sending events
+ // repeatedly.
+ //
+ // This is only available with the Kitty Keyboard Protocol or the Windows
+ // Console API.
+ IsRepeat bool
+}
+
+// MatchString returns true if the [Key] matches one of the given strings.
+//
+// A string can be a key name like "enter", "tab", "a", or a printable
+// character like "1" or " ". It can also have combinations of modifiers like
+// "ctrl+a", "shift+enter", "alt+tab", "ctrl+shift+enter", etc.
+func (k Key) MatchString(s ...string) bool {
+ for _, s := range s {
+ if keyMatchString(k, s) {
+ return true
+ }
+ }
+ return false
+}
+
+func keyMatchString(k Key, s string) bool {
+ var (
+ mod KeyMod
+ code rune
+ text string
+ )
+ parts := strings.Split(s, "+")
+ for _, part := range parts {
+ switch part {
+ case "ctrl":
+ mod |= ModCtrl
+ case "alt":
+ mod |= ModAlt
+ case "shift":
+ mod |= ModShift
+ case "meta":
+ mod |= ModMeta
+ case "hyper":
+ mod |= ModHyper
+ case "super":
+ mod |= ModSuper
+ case "capslock":
+ mod |= ModCapsLock
+ case "scrolllock":
+ mod |= ModScrollLock
+ case "numlock":
+ mod |= ModNumLock
+ default:
+ // Check if the part is a key name.
+ if k, ok := stringKeyType[part]; ok {
+ code = k
+ } else {
+ // Check if the part is a printable character.
+ if utf8.RuneCountInString(part) == 1 {
+ code, _ = utf8.DecodeRuneInString(part)
+ } else {
+ // Multi-rune key.
+ code = KeyExtended
+ text = part
+ }
+ }
+ }
+ }
+
+ // Check if we have a printable character.
+ smod := mod &^ (ModShift | ModCapsLock)
+ if smod == 0 && text == "" && unicode.IsPrint(code) {
+ if mod&ModShift != 0 || mod&ModCapsLock != 0 {
+ // Shifted code we need to use uppercase.
+ text = string(unicode.ToUpper(code))
+ } else {
+ // Otherwise, use the code as is.
+ text = string(code)
+ }
+ }
+
+ // Check if we have a match.
+ return (k.Mod == mod && k.Code == code) ||
+ (k.Text != "" && k.Text == text)
+}
+
+// String implements [fmt.Stringer] and is quite useful for matching key
+// events. It will return the textual representation of the [Key] if there is
+// one, otherwise, it will fallback to [Key.Keystroke].
+//
+// For example, you'll always get "?" and instead of "shift+/" on a US ANSI
+// keyboard.
+func (k Key) String() string {
+ if len(k.Text) > 0 && k.Text != " " {
+ return k.Text
+ }
+ return k.Keystroke()
+}
+
+// Keystroke returns the keystroke representation of the [Key]. While less type
+// safe than looking at the individual fields, it will usually be more
+// convenient and readable to use this method when matching against keys.
+//
+// Note that modifier keys are always printed in the following order:
+// - ctrl
+// - alt
+// - shift
+// - meta
+// - hyper
+// - super
+//
+// For example, you'll always see "ctrl+shift+alt+a" and never
+// "shift+ctrl+alt+a".
+func (k Key) Keystroke() string {
+ var sb strings.Builder
+ if k.Mod.Contains(ModCtrl) && k.Code != KeyLeftCtrl && k.Code != KeyRightCtrl {
+ sb.WriteString("ctrl+")
+ }
+ if k.Mod.Contains(ModAlt) && k.Code != KeyLeftAlt && k.Code != KeyRightAlt {
+ sb.WriteString("alt+")
+ }
+ if k.Mod.Contains(ModShift) && k.Code != KeyLeftShift && k.Code != KeyRightShift {
+ sb.WriteString("shift+")
+ }
+ if k.Mod.Contains(ModMeta) && k.Code != KeyLeftMeta && k.Code != KeyRightMeta {
+ sb.WriteString("meta+")
+ }
+ if k.Mod.Contains(ModHyper) && k.Code != KeyLeftHyper && k.Code != KeyRightHyper {
+ sb.WriteString("hyper+")
+ }
+ if k.Mod.Contains(ModSuper) && k.Code != KeyLeftSuper && k.Code != KeyRightSuper {
+ sb.WriteString("super+")
+ }
+
+ if kt, ok := keyTypeString[k.Code]; ok {
+ sb.WriteString(kt)
+ } else {
+ code := k.Code
+ if k.BaseCode != 0 {
+ // If a [Key.BaseCode] is present, use it to represent a key using the standard
+ // PC-101 key layout.
+ code = k.BaseCode
+ }
+
+ switch code {
+ case KeySpace:
+ // Space is the only invisible printable character.
+ sb.WriteString("space")
+ case KeyExtended:
+ // Write the actual text of the key when the key contains multiple
+ // runes.
+ sb.WriteString(k.Text)
+ default:
+ sb.WriteRune(code)
+ }
+ }
+
+ return sb.String()
+}
+
+var keyTypeString = map[rune]string{
+ KeyEnter: "enter",
+ KeyTab: "tab",
+ KeyBackspace: "backspace",
+ KeyEscape: "esc",
+ KeySpace: "space",
+ KeyUp: "up",
+ KeyDown: "down",
+ KeyLeft: "left",
+ KeyRight: "right",
+ KeyBegin: "begin",
+ KeyFind: "find",
+ KeyInsert: "insert",
+ KeyDelete: "delete",
+ KeySelect: "select",
+ KeyPgUp: "pgup",
+ KeyPgDown: "pgdown",
+ KeyHome: "home",
+ KeyEnd: "end",
+ KeyKpEnter: "enter",
+ KeyKpEqual: "equal",
+ KeyKpMultiply: "mul",
+ KeyKpPlus: "plus",
+ KeyKpComma: "comma",
+ KeyKpMinus: "minus",
+ KeyKpDecimal: "period",
+ KeyKpDivide: "div",
+ KeyKp0: "0",
+ KeyKp1: "1",
+ KeyKp2: "2",
+ KeyKp3: "3",
+ KeyKp4: "4",
+ KeyKp5: "5",
+ KeyKp6: "6",
+ KeyKp7: "7",
+ KeyKp8: "8",
+ KeyKp9: "9",
+
+ // Kitty keyboard extension
+ KeyKpSep: "sep",
+ KeyKpUp: "up",
+ KeyKpDown: "down",
+ KeyKpLeft: "left",
+ KeyKpRight: "right",
+ KeyKpPgUp: "pgup",
+ KeyKpPgDown: "pgdown",
+ KeyKpHome: "home",
+ KeyKpEnd: "end",
+ KeyKpInsert: "insert",
+ KeyKpDelete: "delete",
+ KeyKpBegin: "begin",
+
+ KeyF1: "f1",
+ KeyF2: "f2",
+ KeyF3: "f3",
+ KeyF4: "f4",
+ KeyF5: "f5",
+ KeyF6: "f6",
+ KeyF7: "f7",
+ KeyF8: "f8",
+ KeyF9: "f9",
+ KeyF10: "f10",
+ KeyF11: "f11",
+ KeyF12: "f12",
+ KeyF13: "f13",
+ KeyF14: "f14",
+ KeyF15: "f15",
+ KeyF16: "f16",
+ KeyF17: "f17",
+ KeyF18: "f18",
+ KeyF19: "f19",
+ KeyF20: "f20",
+ KeyF21: "f21",
+ KeyF22: "f22",
+ KeyF23: "f23",
+ KeyF24: "f24",
+ KeyF25: "f25",
+ KeyF26: "f26",
+ KeyF27: "f27",
+ KeyF28: "f28",
+ KeyF29: "f29",
+ KeyF30: "f30",
+ KeyF31: "f31",
+ KeyF32: "f32",
+ KeyF33: "f33",
+ KeyF34: "f34",
+ KeyF35: "f35",
+ KeyF36: "f36",
+ KeyF37: "f37",
+ KeyF38: "f38",
+ KeyF39: "f39",
+ KeyF40: "f40",
+ KeyF41: "f41",
+ KeyF42: "f42",
+ KeyF43: "f43",
+ KeyF44: "f44",
+ KeyF45: "f45",
+ KeyF46: "f46",
+ KeyF47: "f47",
+ KeyF48: "f48",
+ KeyF49: "f49",
+ KeyF50: "f50",
+ KeyF51: "f51",
+ KeyF52: "f52",
+ KeyF53: "f53",
+ KeyF54: "f54",
+ KeyF55: "f55",
+ KeyF56: "f56",
+ KeyF57: "f57",
+ KeyF58: "f58",
+ KeyF59: "f59",
+ KeyF60: "f60",
+ KeyF61: "f61",
+ KeyF62: "f62",
+ KeyF63: "f63",
+
+ // Kitty keyboard extension
+ KeyCapsLock: "capslock",
+ KeyScrollLock: "scrolllock",
+ KeyNumLock: "numlock",
+ KeyPrintScreen: "printscreen",
+ KeyPause: "pause",
+ KeyMenu: "menu",
+ KeyMediaPlay: "mediaplay",
+ KeyMediaPause: "mediapause",
+ KeyMediaPlayPause: "mediaplaypause",
+ KeyMediaReverse: "mediareverse",
+ KeyMediaStop: "mediastop",
+ KeyMediaFastForward: "mediafastforward",
+ KeyMediaRewind: "mediarewind",
+ KeyMediaNext: "medianext",
+ KeyMediaPrev: "mediaprev",
+ KeyMediaRecord: "mediarecord",
+ KeyLowerVol: "lowervol",
+ KeyRaiseVol: "raisevol",
+ KeyMute: "mute",
+ KeyLeftShift: "leftshift",
+ KeyLeftAlt: "leftalt",
+ KeyLeftCtrl: "leftctrl",
+ KeyLeftSuper: "leftsuper",
+ KeyLeftHyper: "lefthyper",
+ KeyLeftMeta: "leftmeta",
+ KeyRightShift: "rightshift",
+ KeyRightAlt: "rightalt",
+ KeyRightCtrl: "rightctrl",
+ KeyRightSuper: "rightsuper",
+ KeyRightHyper: "righthyper",
+ KeyRightMeta: "rightmeta",
+ KeyIsoLevel3Shift: "isolevel3shift",
+ KeyIsoLevel5Shift: "isolevel5shift",
+}
+
+var stringKeyType = map[string]rune{
+ "enter": KeyEnter,
+ "tab": KeyTab,
+ "backspace": KeyBackspace,
+ "escape": KeyEscape,
+ "esc": KeyEscape,
+ "space": KeySpace,
+ "up": KeyUp,
+ "down": KeyDown,
+ "left": KeyLeft,
+ "right": KeyRight,
+ "begin": KeyBegin,
+ "find": KeyFind,
+ "insert": KeyInsert,
+ "delete": KeyDelete,
+ "select": KeySelect,
+ "pgup": KeyPgUp,
+ "pgdown": KeyPgDown,
+ "home": KeyHome,
+ "end": KeyEnd,
+ "kpenter": KeyKpEnter,
+ "kpequal": KeyKpEqual,
+ "kpmul": KeyKpMultiply,
+ "kpplus": KeyKpPlus,
+ "kpcomma": KeyKpComma,
+ "kpminus": KeyKpMinus,
+ "kpperiod": KeyKpDecimal,
+ "kpdiv": KeyKpDivide,
+ "kp0": KeyKp0,
+ "kp1": KeyKp1,
+ "kp2": KeyKp2,
+ "kp3": KeyKp3,
+ "kp4": KeyKp4,
+ "kp5": KeyKp5,
+ "kp6": KeyKp6,
+ "kp7": KeyKp7,
+ "kp8": KeyKp8,
+ "kp9": KeyKp9,
+
+ // Kitty keyboard extension
+ "kpsep": KeyKpSep,
+ "kpup": KeyKpUp,
+ "kpdown": KeyKpDown,
+ "kpleft": KeyKpLeft,
+ "kpright": KeyKpRight,
+ "kppgup": KeyKpPgUp,
+ "kppgdown": KeyKpPgDown,
+ "kphome": KeyKpHome,
+ "kpend": KeyKpEnd,
+ "kpinsert": KeyKpInsert,
+ "kpdelete": KeyKpDelete,
+ "kpbegin": KeyKpBegin,
+
+ "f1": KeyF1,
+ "f2": KeyF2,
+ "f3": KeyF3,
+ "f4": KeyF4,
+ "f5": KeyF5,
+ "f6": KeyF6,
+ "f7": KeyF7,
+ "f8": KeyF8,
+ "f9": KeyF9,
+ "f10": KeyF10,
+ "f11": KeyF11,
+ "f12": KeyF12,
+ "f13": KeyF13,
+ "f14": KeyF14,
+ "f15": KeyF15,
+ "f16": KeyF16,
+ "f17": KeyF17,
+ "f18": KeyF18,
+ "f19": KeyF19,
+ "f20": KeyF20,
+ "f21": KeyF21,
+ "f22": KeyF22,
+ "f23": KeyF23,
+ "f24": KeyF24,
+ "f25": KeyF25,
+ "f26": KeyF26,
+ "f27": KeyF27,
+ "f28": KeyF28,
+ "f29": KeyF29,
+ "f30": KeyF30,
+ "f31": KeyF31,
+ "f32": KeyF32,
+ "f33": KeyF33,
+ "f34": KeyF34,
+ "f35": KeyF35,
+ "f36": KeyF36,
+ "f37": KeyF37,
+ "f38": KeyF38,
+ "f39": KeyF39,
+ "f40": KeyF40,
+ "f41": KeyF41,
+ "f42": KeyF42,
+ "f43": KeyF43,
+ "f44": KeyF44,
+ "f45": KeyF45,
+ "f46": KeyF46,
+ "f47": KeyF47,
+ "f48": KeyF48,
+ "f49": KeyF49,
+ "f50": KeyF50,
+ "f51": KeyF51,
+ "f52": KeyF52,
+ "f53": KeyF53,
+ "f54": KeyF54,
+ "f55": KeyF55,
+ "f56": KeyF56,
+ "f57": KeyF57,
+ "f58": KeyF58,
+ "f59": KeyF59,
+ "f60": KeyF60,
+ "f61": KeyF61,
+ "f62": KeyF62,
+ "f63": KeyF63,
+
+ // Kitty keyboard extension
+ "capslock": KeyCapsLock,
+ "scrolllock": KeyScrollLock,
+ "numlock": KeyNumLock,
+ "printscreen": KeyPrintScreen,
+ "pause": KeyPause,
+ "menu": KeyMenu,
+ "mediaplay": KeyMediaPlay,
+ "mediapause": KeyMediaPause,
+ "mediaplaypause": KeyMediaPlayPause,
+ "mediareverse": KeyMediaReverse,
+ "mediastop": KeyMediaStop,
+ "mediafastforward": KeyMediaFastForward,
+ "mediarewind": KeyMediaRewind,
+ "medianext": KeyMediaNext,
+ "mediaprev": KeyMediaPrev,
+ "mediarecord": KeyMediaRecord,
+ "lowervol": KeyLowerVol,
+ "raisevol": KeyRaiseVol,
+ "mute": KeyMute,
+ "leftshift": KeyLeftShift,
+ "leftalt": KeyLeftAlt,
+ "leftctrl": KeyLeftCtrl,
+ "leftsuper": KeyLeftSuper,
+ "lefthyper": KeyLeftHyper,
+ "leftmeta": KeyLeftMeta,
+ "rightshift": KeyRightShift,
+ "rightalt": KeyRightAlt,
+ "rightctrl": KeyRightCtrl,
+ "rightsuper": KeyRightSuper,
+ "righthyper": KeyRightHyper,
+ "rightmeta": KeyRightMeta,
+ "isolevel3shift": KeyIsoLevel3Shift,
+ "isolevel5shift": KeyIsoLevel5Shift,
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/key_table.go b/vendor/github.com/charmbracelet/ultraviolet/key_table.go
new file mode 100644
index 000000000..285ed70fa
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/key_table.go
@@ -0,0 +1,664 @@
+package uv
+
+import (
+ "strconv"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/xo/terminfo"
+)
+
+// buildKeysTable builds a table of key sequences and their corresponding key
+// events based on the VT100/VT200, XTerm, and Urxvt terminal specs.
+func buildKeysTable(flags LegacyKeyEncoding, term string, useTerminfo bool) map[string]Key {
+ nul := Key{Code: KeySpace, Mod: ModCtrl} // ctrl+@ or ctrl+space
+ if flags&flagCtrlAt != 0 {
+ nul = Key{Code: '@', Mod: ModCtrl}
+ }
+
+ tab := Key{Code: KeyTab} // ctrl+i or tab
+ if flags&flagCtrlI != 0 {
+ tab = Key{Code: 'i', Mod: ModCtrl}
+ }
+
+ enter := Key{Code: KeyEnter} // ctrl+m or enter
+ if flags&flagCtrlM != 0 {
+ enter = Key{Code: 'm', Mod: ModCtrl}
+ }
+
+ esc := Key{Code: KeyEscape} // ctrl+[ or escape
+ if flags&flagCtrlOpenBracket != 0 {
+ esc = Key{Code: '[', Mod: ModCtrl} // ctrl+[ or escape
+ }
+
+ del := Key{Code: KeyBackspace}
+ if flags&flagBackspace != 0 {
+ del.Code = KeyDelete
+ }
+
+ find := Key{Code: KeyHome}
+ if flags&flagFind != 0 {
+ find.Code = KeyFind
+ }
+
+ sel := Key{Code: KeyEnd}
+ if flags&flagSelect != 0 {
+ sel.Code = KeySelect
+ }
+
+ // The following is a table of key sequences and their corresponding key
+ // events based on the VT100/VT200 terminal specs.
+ //
+ // See: https://vt100.net/docs/vt100-ug/chapter3.html#S3.2
+ // See: https://vt100.net/docs/vt220-rm/chapter3.html
+ //
+ // XXX: These keys may be overwritten by other options like XTerm or
+ // Terminfo.
+ table := map[string]Key{
+ // C0 control characters
+ string(byte(ansi.NUL)): nul,
+ string(byte(ansi.SOH)): {Code: 'a', Mod: ModCtrl},
+ string(byte(ansi.STX)): {Code: 'b', Mod: ModCtrl},
+ string(byte(ansi.ETX)): {Code: 'c', Mod: ModCtrl},
+ string(byte(ansi.EOT)): {Code: 'd', Mod: ModCtrl},
+ string(byte(ansi.ENQ)): {Code: 'e', Mod: ModCtrl},
+ string(byte(ansi.ACK)): {Code: 'f', Mod: ModCtrl},
+ string(byte(ansi.BEL)): {Code: 'g', Mod: ModCtrl},
+ string(byte(ansi.BS)): {Code: 'h', Mod: ModCtrl},
+ string(byte(ansi.HT)): tab,
+ string(byte(ansi.LF)): {Code: 'j', Mod: ModCtrl},
+ string(byte(ansi.VT)): {Code: 'k', Mod: ModCtrl},
+ string(byte(ansi.FF)): {Code: 'l', Mod: ModCtrl},
+ string(byte(ansi.CR)): enter,
+ string(byte(ansi.SO)): {Code: 'n', Mod: ModCtrl},
+ string(byte(ansi.SI)): {Code: 'o', Mod: ModCtrl},
+ string(byte(ansi.DLE)): {Code: 'p', Mod: ModCtrl},
+ string(byte(ansi.DC1)): {Code: 'q', Mod: ModCtrl},
+ string(byte(ansi.DC2)): {Code: 'r', Mod: ModCtrl},
+ string(byte(ansi.DC3)): {Code: 's', Mod: ModCtrl},
+ string(byte(ansi.DC4)): {Code: 't', Mod: ModCtrl},
+ string(byte(ansi.NAK)): {Code: 'u', Mod: ModCtrl},
+ string(byte(ansi.SYN)): {Code: 'v', Mod: ModCtrl},
+ string(byte(ansi.ETB)): {Code: 'w', Mod: ModCtrl},
+ string(byte(ansi.CAN)): {Code: 'x', Mod: ModCtrl},
+ string(byte(ansi.EM)): {Code: 'y', Mod: ModCtrl},
+ string(byte(ansi.SUB)): {Code: 'z', Mod: ModCtrl},
+ string(byte(ansi.ESC)): esc,
+ string(byte(ansi.FS)): {Code: '\\', Mod: ModCtrl},
+ string(byte(ansi.GS)): {Code: ']', Mod: ModCtrl},
+ string(byte(ansi.RS)): {Code: '^', Mod: ModCtrl},
+ string(byte(ansi.US)): {Code: '_', Mod: ModCtrl},
+
+ // Special keys in G0
+ string(byte(ansi.SP)): {Code: KeySpace, Text: " "},
+ string(byte(ansi.DEL)): del,
+
+ // Special keys
+
+ "\x1b[Z": {Code: KeyTab, Mod: ModShift},
+
+ "\x1b[1~": find,
+ "\x1b[2~": {Code: KeyInsert},
+ "\x1b[3~": {Code: KeyDelete},
+ "\x1b[4~": sel,
+ "\x1b[5~": {Code: KeyPgUp},
+ "\x1b[6~": {Code: KeyPgDown},
+ "\x1b[7~": {Code: KeyHome},
+ "\x1b[8~": {Code: KeyEnd},
+
+ // Normal mode
+ "\x1b[A": {Code: KeyUp},
+ "\x1b[B": {Code: KeyDown},
+ "\x1b[C": {Code: KeyRight},
+ "\x1b[D": {Code: KeyLeft},
+ "\x1b[E": {Code: KeyBegin},
+ "\x1b[F": {Code: KeyEnd},
+ "\x1b[H": {Code: KeyHome},
+ "\x1b[P": {Code: KeyF1},
+ "\x1b[Q": {Code: KeyF2},
+ "\x1b[R": {Code: KeyF3},
+ "\x1b[S": {Code: KeyF4},
+
+ // Application Cursor Key Mode (DECCKM)
+ "\x1bOA": {Code: KeyUp},
+ "\x1bOB": {Code: KeyDown},
+ "\x1bOC": {Code: KeyRight},
+ "\x1bOD": {Code: KeyLeft},
+ "\x1bOE": {Code: KeyBegin},
+ "\x1bOF": {Code: KeyEnd},
+ "\x1bOH": {Code: KeyHome},
+ "\x1bOP": {Code: KeyF1},
+ "\x1bOQ": {Code: KeyF2},
+ "\x1bOR": {Code: KeyF3},
+ "\x1bOS": {Code: KeyF4},
+
+ // Keypad Application Mode (DECKPAM)
+
+ "\x1bOM": {Code: KeyKpEnter},
+ "\x1bOX": {Code: KeyKpEqual},
+ "\x1bOj": {Code: KeyKpMultiply},
+ "\x1bOk": {Code: KeyKpPlus},
+ "\x1bOl": {Code: KeyKpComma},
+ "\x1bOm": {Code: KeyKpMinus},
+ "\x1bOn": {Code: KeyKpDecimal},
+ "\x1bOo": {Code: KeyKpDivide},
+ "\x1bOp": {Code: KeyKp0},
+ "\x1bOq": {Code: KeyKp1},
+ "\x1bOr": {Code: KeyKp2},
+ "\x1bOs": {Code: KeyKp3},
+ "\x1bOt": {Code: KeyKp4},
+ "\x1bOu": {Code: KeyKp5},
+ "\x1bOv": {Code: KeyKp6},
+ "\x1bOw": {Code: KeyKp7},
+ "\x1bOx": {Code: KeyKp8},
+ "\x1bOy": {Code: KeyKp9},
+
+ // Function keys
+
+ "\x1b[11~": {Code: KeyF1},
+ "\x1b[12~": {Code: KeyF2},
+ "\x1b[13~": {Code: KeyF3},
+ "\x1b[14~": {Code: KeyF4},
+ "\x1b[15~": {Code: KeyF5},
+ "\x1b[17~": {Code: KeyF6},
+ "\x1b[18~": {Code: KeyF7},
+ "\x1b[19~": {Code: KeyF8},
+ "\x1b[20~": {Code: KeyF9},
+ "\x1b[21~": {Code: KeyF10},
+ "\x1b[23~": {Code: KeyF11},
+ "\x1b[24~": {Code: KeyF12},
+ "\x1b[25~": {Code: KeyF13},
+ "\x1b[26~": {Code: KeyF14},
+ "\x1b[28~": {Code: KeyF15},
+ "\x1b[29~": {Code: KeyF16},
+ "\x1b[31~": {Code: KeyF17},
+ "\x1b[32~": {Code: KeyF18},
+ "\x1b[33~": {Code: KeyF19},
+ "\x1b[34~": {Code: KeyF20},
+ }
+
+ // CSI ~ sequence keys
+ csiTildeKeys := map[string]Key{
+ "1": find, "2": {Code: KeyInsert},
+ "3": {Code: KeyDelete}, "4": sel,
+ "5": {Code: KeyPgUp}, "6": {Code: KeyPgDown},
+ "7": {Code: KeyHome}, "8": {Code: KeyEnd},
+ // There are no 9 and 10 keys
+ "11": {Code: KeyF1}, "12": {Code: KeyF2},
+ "13": {Code: KeyF3}, "14": {Code: KeyF4},
+ "15": {Code: KeyF5}, "17": {Code: KeyF6},
+ "18": {Code: KeyF7}, "19": {Code: KeyF8},
+ "20": {Code: KeyF9}, "21": {Code: KeyF10},
+ "23": {Code: KeyF11}, "24": {Code: KeyF12},
+ "25": {Code: KeyF13}, "26": {Code: KeyF14},
+ "28": {Code: KeyF15}, "29": {Code: KeyF16},
+ "31": {Code: KeyF17}, "32": {Code: KeyF18},
+ "33": {Code: KeyF19}, "34": {Code: KeyF20},
+ }
+
+ // URxvt keys
+ // See https://manpages.ubuntu.com/manpages/trusty/man7/urxvt.7.html#key%20codes
+ table["\x1b[a"] = Key{Code: KeyUp, Mod: ModShift}
+ table["\x1b[b"] = Key{Code: KeyDown, Mod: ModShift}
+ table["\x1b[c"] = Key{Code: KeyRight, Mod: ModShift}
+ table["\x1b[d"] = Key{Code: KeyLeft, Mod: ModShift}
+ table["\x1bOa"] = Key{Code: KeyUp, Mod: ModCtrl}
+ table["\x1bOb"] = Key{Code: KeyDown, Mod: ModCtrl}
+ table["\x1bOc"] = Key{Code: KeyRight, Mod: ModCtrl}
+ table["\x1bOd"] = Key{Code: KeyLeft, Mod: ModCtrl}
+ //nolint:godox
+ // TODO: invistigate if shift-ctrl arrow keys collide with DECCKM keys i.e.
+ // "\x1bOA", "\x1bOB", "\x1bOC", "\x1bOD"
+
+ // URxvt modifier CSI ~ keys
+ for k, v := range csiTildeKeys {
+ key := v
+ // Normal (no modifier) already defined part of VT100/VT200
+ // Shift modifier
+ key.Mod = ModShift
+ table["\x1b["+k+"$"] = key
+ // Ctrl modifier
+ key.Mod = ModCtrl
+ table["\x1b["+k+"^"] = key
+ // Shift-Ctrl modifier
+ key.Mod = ModShift | ModCtrl
+ table["\x1b["+k+"@"] = key
+ }
+
+ // URxvt F keys
+ // Note: Shift + F1-F10 generates F11-F20.
+ // This means Shift + F1 and Shift + F2 will generate F11 and F12, the same
+ // applies to Ctrl + Shift F1 & F2.
+ //
+ // P.S. Don't like this? Blame URxvt, configure your terminal to use
+ // different escapes like XTerm, or switch to a better terminal ¯\_(ツ)_/¯
+ //
+ // See https://manpages.ubuntu.com/manpages/trusty/man7/urxvt.7.html#key%20codes
+ table["\x1b[23$"] = Key{Code: KeyF11, Mod: ModShift}
+ table["\x1b[24$"] = Key{Code: KeyF12, Mod: ModShift}
+ table["\x1b[25$"] = Key{Code: KeyF13, Mod: ModShift}
+ table["\x1b[26$"] = Key{Code: KeyF14, Mod: ModShift}
+ table["\x1b[28$"] = Key{Code: KeyF15, Mod: ModShift}
+ table["\x1b[29$"] = Key{Code: KeyF16, Mod: ModShift}
+ table["\x1b[31$"] = Key{Code: KeyF17, Mod: ModShift}
+ table["\x1b[32$"] = Key{Code: KeyF18, Mod: ModShift}
+ table["\x1b[33$"] = Key{Code: KeyF19, Mod: ModShift}
+ table["\x1b[34$"] = Key{Code: KeyF20, Mod: ModShift}
+ table["\x1b[11^"] = Key{Code: KeyF1, Mod: ModCtrl}
+ table["\x1b[12^"] = Key{Code: KeyF2, Mod: ModCtrl}
+ table["\x1b[13^"] = Key{Code: KeyF3, Mod: ModCtrl}
+ table["\x1b[14^"] = Key{Code: KeyF4, Mod: ModCtrl}
+ table["\x1b[15^"] = Key{Code: KeyF5, Mod: ModCtrl}
+ table["\x1b[17^"] = Key{Code: KeyF6, Mod: ModCtrl}
+ table["\x1b[18^"] = Key{Code: KeyF7, Mod: ModCtrl}
+ table["\x1b[19^"] = Key{Code: KeyF8, Mod: ModCtrl}
+ table["\x1b[20^"] = Key{Code: KeyF9, Mod: ModCtrl}
+ table["\x1b[21^"] = Key{Code: KeyF10, Mod: ModCtrl}
+ table["\x1b[23^"] = Key{Code: KeyF11, Mod: ModCtrl}
+ table["\x1b[24^"] = Key{Code: KeyF12, Mod: ModCtrl}
+ table["\x1b[25^"] = Key{Code: KeyF13, Mod: ModCtrl}
+ table["\x1b[26^"] = Key{Code: KeyF14, Mod: ModCtrl}
+ table["\x1b[28^"] = Key{Code: KeyF15, Mod: ModCtrl}
+ table["\x1b[29^"] = Key{Code: KeyF16, Mod: ModCtrl}
+ table["\x1b[31^"] = Key{Code: KeyF17, Mod: ModCtrl}
+ table["\x1b[32^"] = Key{Code: KeyF18, Mod: ModCtrl}
+ table["\x1b[33^"] = Key{Code: KeyF19, Mod: ModCtrl}
+ table["\x1b[34^"] = Key{Code: KeyF20, Mod: ModCtrl}
+ table["\x1b[23@"] = Key{Code: KeyF11, Mod: ModShift | ModCtrl}
+ table["\x1b[24@"] = Key{Code: KeyF12, Mod: ModShift | ModCtrl}
+ table["\x1b[25@"] = Key{Code: KeyF13, Mod: ModShift | ModCtrl}
+ table["\x1b[26@"] = Key{Code: KeyF14, Mod: ModShift | ModCtrl}
+ table["\x1b[28@"] = Key{Code: KeyF15, Mod: ModShift | ModCtrl}
+ table["\x1b[29@"] = Key{Code: KeyF16, Mod: ModShift | ModCtrl}
+ table["\x1b[31@"] = Key{Code: KeyF17, Mod: ModShift | ModCtrl}
+ table["\x1b[32@"] = Key{Code: KeyF18, Mod: ModShift | ModCtrl}
+ table["\x1b[33@"] = Key{Code: KeyF19, Mod: ModShift | ModCtrl}
+ table["\x1b[34@"] = Key{Code: KeyF20, Mod: ModShift | ModCtrl}
+
+ // Register Alt + combinations
+ // XXX: this must come after URxvt but before XTerm keys to register URxvt
+ // keys with alt modifier
+ tmap := map[string]Key{}
+ for seq, key := range table {
+ key := key
+ key.Mod |= ModAlt
+ key.Text = "" // Clear runes
+ tmap["\x1b"+seq] = key
+ }
+ for seq, key := range tmap {
+ table[seq] = key
+ }
+
+ // XTerm modifiers
+ // These are offset by 1 to be compatible with our Mod type.
+ // See https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-PC-Style-Function-Keys
+ modifiers := []KeyMod{
+ ModShift, // 1
+ ModAlt, // 2
+ ModShift | ModAlt, // 3
+ ModCtrl, // 4
+ ModShift | ModCtrl, // 5
+ ModAlt | ModCtrl, // 6
+ ModShift | ModAlt | ModCtrl, // 7
+ ModMeta, // 8
+ ModMeta | ModShift, // 9
+ ModMeta | ModAlt, // 10
+ ModMeta | ModShift | ModAlt, // 11
+ ModMeta | ModCtrl, // 12
+ ModMeta | ModShift | ModCtrl, // 13
+ ModMeta | ModAlt | ModCtrl, // 14
+ ModMeta | ModShift | ModAlt | ModCtrl, // 15
+ }
+
+ // SS3 keypad function keys
+ ss3FuncKeys := map[string]Key{
+ // These are defined in XTerm
+ // Taken from Foot keymap.h and XTerm modifyOtherKeys
+ // https://codeberg.org/dnkl/foot/src/branch/master/keymap.h
+ "M": {Code: KeyKpEnter}, "X": {Code: KeyKpEqual},
+ "j": {Code: KeyKpMultiply}, "k": {Code: KeyKpPlus},
+ "l": {Code: KeyKpComma}, "m": {Code: KeyKpMinus},
+ "n": {Code: KeyKpDecimal}, "o": {Code: KeyKpDivide},
+ "p": {Code: KeyKp0}, "q": {Code: KeyKp1},
+ "r": {Code: KeyKp2}, "s": {Code: KeyKp3},
+ "t": {Code: KeyKp4}, "u": {Code: KeyKp5},
+ "v": {Code: KeyKp6}, "w": {Code: KeyKp7},
+ "x": {Code: KeyKp8}, "y": {Code: KeyKp9},
+ }
+
+ // XTerm keys
+ csiFuncKeys := map[string]Key{
+ "A": {Code: KeyUp}, "B": {Code: KeyDown},
+ "C": {Code: KeyRight}, "D": {Code: KeyLeft},
+ "E": {Code: KeyBegin}, "F": {Code: KeyEnd},
+ "H": {Code: KeyHome}, "P": {Code: KeyF1},
+ "Q": {Code: KeyF2}, "R": {Code: KeyF3},
+ "S": {Code: KeyF4},
+ }
+
+ // CSI 27 ; ; ~ keys defined in XTerm modifyOtherKeys
+ modifyOtherKeys := map[int]Key{
+ ansi.BS: {Code: KeyBackspace},
+ ansi.HT: {Code: KeyTab},
+ ansi.CR: {Code: KeyEnter},
+ ansi.ESC: {Code: KeyEscape},
+ ansi.DEL: {Code: KeyBackspace},
+ }
+
+ for _, m := range modifiers {
+ // XTerm modifier offset +1
+ xtermMod := strconv.Itoa(int(m) + 1)
+
+ // CSI 1 ;
+ for k, v := range csiFuncKeys {
+ // Functions always have a leading 1 param
+ seq := "\x1b[1;" + xtermMod + k
+ key := v
+ key.Mod = m
+ table[seq] = key
+ }
+ // SS3
+ for k, v := range ss3FuncKeys {
+ seq := "\x1bO" + xtermMod + k
+ key := v
+ key.Mod = m
+ table[seq] = key
+ }
+ // CSI ; ~
+ for k, v := range csiTildeKeys {
+ seq := "\x1b[" + k + ";" + xtermMod + "~"
+ key := v
+ key.Mod = m
+ table[seq] = key
+ }
+ // CSI 27 ; ; ~
+ for k, v := range modifyOtherKeys {
+ code := strconv.Itoa(k)
+ seq := "\x1b[27;" + xtermMod + ";" + code + "~"
+ key := v
+ key.Mod = m
+ table[seq] = key
+ }
+ }
+
+ // Register terminfo keys
+ // XXX: this might override keys already registered in table
+ if useTerminfo {
+ titable := buildTerminfoKeys(flags, term)
+ for seq, key := range titable {
+ table[seq] = key
+ }
+ }
+
+ return table
+}
+
+func buildTerminfoKeys(flags LegacyKeyEncoding, term string) map[string]Key {
+ table := make(map[string]Key)
+ ti, _ := terminfo.Load(term)
+ if ti == nil {
+ return table
+ }
+
+ tiTable := defaultTerminfoKeys(flags)
+
+ // Default keys
+ for name, seq := range ti.StringCapsShort() {
+ if !strings.HasPrefix(name, "k") || len(seq) == 0 {
+ continue
+ }
+
+ if k, ok := tiTable[name]; ok {
+ table[string(seq)] = k
+ }
+ }
+
+ // Extended keys
+ for name, seq := range ti.ExtStringCapsShort() {
+ if !strings.HasPrefix(name, "k") || len(seq) == 0 {
+ continue
+ }
+
+ if k, ok := tiTable[name]; ok {
+ table[string(seq)] = k
+ }
+ }
+
+ return table
+}
+
+// This returns a map of terminfo keys to key events. It's a mix of ncurses
+// terminfo default and user-defined key capabilities.
+// Upper-case caps that are defined in the default terminfo database are
+// - kNXT
+// - kPRV
+// - kHOM
+// - kEND
+// - kDC
+// - kIC
+// - kLFT
+// - kRIT
+//
+// See https://man7.org/linux/man-pages/man5/terminfo.5.html
+// See https://github.com/mirror/ncurses/blob/master/include/Caps-ncurses
+func defaultTerminfoKeys(flags LegacyKeyEncoding) map[string]Key {
+ keys := map[string]Key{
+ "kcuu1": {Code: KeyUp},
+ "kUP": {Code: KeyUp, Mod: ModShift},
+ "kUP3": {Code: KeyUp, Mod: ModAlt},
+ "kUP4": {Code: KeyUp, Mod: ModShift | ModAlt},
+ "kUP5": {Code: KeyUp, Mod: ModCtrl},
+ "kUP6": {Code: KeyUp, Mod: ModShift | ModCtrl},
+ "kUP7": {Code: KeyUp, Mod: ModAlt | ModCtrl},
+ "kUP8": {Code: KeyUp, Mod: ModShift | ModAlt | ModCtrl},
+ "kcud1": {Code: KeyDown},
+ "kDN": {Code: KeyDown, Mod: ModShift},
+ "kDN3": {Code: KeyDown, Mod: ModAlt},
+ "kDN4": {Code: KeyDown, Mod: ModShift | ModAlt},
+ "kDN5": {Code: KeyDown, Mod: ModCtrl},
+ "kDN7": {Code: KeyDown, Mod: ModAlt | ModCtrl},
+ "kDN6": {Code: KeyDown, Mod: ModShift | ModCtrl},
+ "kDN8": {Code: KeyDown, Mod: ModShift | ModAlt | ModCtrl},
+ "kcub1": {Code: KeyLeft},
+ "kLFT": {Code: KeyLeft, Mod: ModShift},
+ "kLFT3": {Code: KeyLeft, Mod: ModAlt},
+ "kLFT4": {Code: KeyLeft, Mod: ModShift | ModAlt},
+ "kLFT5": {Code: KeyLeft, Mod: ModCtrl},
+ "kLFT6": {Code: KeyLeft, Mod: ModShift | ModCtrl},
+ "kLFT7": {Code: KeyLeft, Mod: ModAlt | ModCtrl},
+ "kLFT8": {Code: KeyLeft, Mod: ModShift | ModAlt | ModCtrl},
+ "kcuf1": {Code: KeyRight},
+ "kRIT": {Code: KeyRight, Mod: ModShift},
+ "kRIT3": {Code: KeyRight, Mod: ModAlt},
+ "kRIT4": {Code: KeyRight, Mod: ModShift | ModAlt},
+ "kRIT5": {Code: KeyRight, Mod: ModCtrl},
+ "kRIT6": {Code: KeyRight, Mod: ModShift | ModCtrl},
+ "kRIT7": {Code: KeyRight, Mod: ModAlt | ModCtrl},
+ "kRIT8": {Code: KeyRight, Mod: ModShift | ModAlt | ModCtrl},
+ "kich1": {Code: KeyInsert},
+ "kIC": {Code: KeyInsert, Mod: ModShift},
+ "kIC3": {Code: KeyInsert, Mod: ModAlt},
+ "kIC4": {Code: KeyInsert, Mod: ModShift | ModAlt},
+ "kIC5": {Code: KeyInsert, Mod: ModCtrl},
+ "kIC6": {Code: KeyInsert, Mod: ModShift | ModCtrl},
+ "kIC7": {Code: KeyInsert, Mod: ModAlt | ModCtrl},
+ "kIC8": {Code: KeyInsert, Mod: ModShift | ModAlt | ModCtrl},
+ "kdch1": {Code: KeyDelete},
+ "kDC": {Code: KeyDelete, Mod: ModShift},
+ "kDC3": {Code: KeyDelete, Mod: ModAlt},
+ "kDC4": {Code: KeyDelete, Mod: ModShift | ModAlt},
+ "kDC5": {Code: KeyDelete, Mod: ModCtrl},
+ "kDC6": {Code: KeyDelete, Mod: ModShift | ModCtrl},
+ "kDC7": {Code: KeyDelete, Mod: ModAlt | ModCtrl},
+ "kDC8": {Code: KeyDelete, Mod: ModShift | ModAlt | ModCtrl},
+ "khome": {Code: KeyHome},
+ "kHOM": {Code: KeyHome, Mod: ModShift},
+ "kHOM3": {Code: KeyHome, Mod: ModAlt},
+ "kHOM4": {Code: KeyHome, Mod: ModShift | ModAlt},
+ "kHOM5": {Code: KeyHome, Mod: ModCtrl},
+ "kHOM6": {Code: KeyHome, Mod: ModShift | ModCtrl},
+ "kHOM7": {Code: KeyHome, Mod: ModAlt | ModCtrl},
+ "kHOM8": {Code: KeyHome, Mod: ModShift | ModAlt | ModCtrl},
+ "kend": {Code: KeyEnd},
+ "kEND": {Code: KeyEnd, Mod: ModShift},
+ "kEND3": {Code: KeyEnd, Mod: ModAlt},
+ "kEND4": {Code: KeyEnd, Mod: ModShift | ModAlt},
+ "kEND5": {Code: KeyEnd, Mod: ModCtrl},
+ "kEND6": {Code: KeyEnd, Mod: ModShift | ModCtrl},
+ "kEND7": {Code: KeyEnd, Mod: ModAlt | ModCtrl},
+ "kEND8": {Code: KeyEnd, Mod: ModShift | ModAlt | ModCtrl},
+ "kpp": {Code: KeyPgUp},
+ "kprv": {Code: KeyPgUp},
+ "kPRV": {Code: KeyPgUp, Mod: ModShift},
+ "kPRV3": {Code: KeyPgUp, Mod: ModAlt},
+ "kPRV4": {Code: KeyPgUp, Mod: ModShift | ModAlt},
+ "kPRV5": {Code: KeyPgUp, Mod: ModCtrl},
+ "kPRV6": {Code: KeyPgUp, Mod: ModShift | ModCtrl},
+ "kPRV7": {Code: KeyPgUp, Mod: ModAlt | ModCtrl},
+ "kPRV8": {Code: KeyPgUp, Mod: ModShift | ModAlt | ModCtrl},
+ "knp": {Code: KeyPgDown},
+ "knxt": {Code: KeyPgDown},
+ "kNXT": {Code: KeyPgDown, Mod: ModShift},
+ "kNXT3": {Code: KeyPgDown, Mod: ModAlt},
+ "kNXT4": {Code: KeyPgDown, Mod: ModShift | ModAlt},
+ "kNXT5": {Code: KeyPgDown, Mod: ModCtrl},
+ "kNXT6": {Code: KeyPgDown, Mod: ModShift | ModCtrl},
+ "kNXT7": {Code: KeyPgDown, Mod: ModAlt | ModCtrl},
+ "kNXT8": {Code: KeyPgDown, Mod: ModShift | ModAlt | ModCtrl},
+
+ "kbs": {Code: KeyBackspace},
+ "kcbt": {Code: KeyTab, Mod: ModShift},
+
+ // Function keys
+ // This only includes the first 12 function keys. The rest are treated
+ // as modifiers of the first 12.
+ // Take a look at XTerm modifyFunctionKeys
+ //
+ // XXX: To use unambiguous function keys, use fixterms or kitty clipboard.
+ //
+ // See https://invisible-island.net/xterm/manpage/xterm.html#VT100-Widget-Resources:modifyFunctionKeys
+ // See https://invisible-island.net/xterm/terminfo.html
+
+ "kf1": {Code: KeyF1},
+ "kf2": {Code: KeyF2},
+ "kf3": {Code: KeyF3},
+ "kf4": {Code: KeyF4},
+ "kf5": {Code: KeyF5},
+ "kf6": {Code: KeyF6},
+ "kf7": {Code: KeyF7},
+ "kf8": {Code: KeyF8},
+ "kf9": {Code: KeyF9},
+ "kf10": {Code: KeyF10},
+ "kf11": {Code: KeyF11},
+ "kf12": {Code: KeyF12},
+ "kf13": {Code: KeyF1, Mod: ModShift},
+ "kf14": {Code: KeyF2, Mod: ModShift},
+ "kf15": {Code: KeyF3, Mod: ModShift},
+ "kf16": {Code: KeyF4, Mod: ModShift},
+ "kf17": {Code: KeyF5, Mod: ModShift},
+ "kf18": {Code: KeyF6, Mod: ModShift},
+ "kf19": {Code: KeyF7, Mod: ModShift},
+ "kf20": {Code: KeyF8, Mod: ModShift},
+ "kf21": {Code: KeyF9, Mod: ModShift},
+ "kf22": {Code: KeyF10, Mod: ModShift},
+ "kf23": {Code: KeyF11, Mod: ModShift},
+ "kf24": {Code: KeyF12, Mod: ModShift},
+ "kf25": {Code: KeyF1, Mod: ModCtrl},
+ "kf26": {Code: KeyF2, Mod: ModCtrl},
+ "kf27": {Code: KeyF3, Mod: ModCtrl},
+ "kf28": {Code: KeyF4, Mod: ModCtrl},
+ "kf29": {Code: KeyF5, Mod: ModCtrl},
+ "kf30": {Code: KeyF6, Mod: ModCtrl},
+ "kf31": {Code: KeyF7, Mod: ModCtrl},
+ "kf32": {Code: KeyF8, Mod: ModCtrl},
+ "kf33": {Code: KeyF9, Mod: ModCtrl},
+ "kf34": {Code: KeyF10, Mod: ModCtrl},
+ "kf35": {Code: KeyF11, Mod: ModCtrl},
+ "kf36": {Code: KeyF12, Mod: ModCtrl},
+ "kf37": {Code: KeyF1, Mod: ModShift | ModCtrl},
+ "kf38": {Code: KeyF2, Mod: ModShift | ModCtrl},
+ "kf39": {Code: KeyF3, Mod: ModShift | ModCtrl},
+ "kf40": {Code: KeyF4, Mod: ModShift | ModCtrl},
+ "kf41": {Code: KeyF5, Mod: ModShift | ModCtrl},
+ "kf42": {Code: KeyF6, Mod: ModShift | ModCtrl},
+ "kf43": {Code: KeyF7, Mod: ModShift | ModCtrl},
+ "kf44": {Code: KeyF8, Mod: ModShift | ModCtrl},
+ "kf45": {Code: KeyF9, Mod: ModShift | ModCtrl},
+ "kf46": {Code: KeyF10, Mod: ModShift | ModCtrl},
+ "kf47": {Code: KeyF11, Mod: ModShift | ModCtrl},
+ "kf48": {Code: KeyF12, Mod: ModShift | ModCtrl},
+ "kf49": {Code: KeyF1, Mod: ModAlt},
+ "kf50": {Code: KeyF2, Mod: ModAlt},
+ "kf51": {Code: KeyF3, Mod: ModAlt},
+ "kf52": {Code: KeyF4, Mod: ModAlt},
+ "kf53": {Code: KeyF5, Mod: ModAlt},
+ "kf54": {Code: KeyF6, Mod: ModAlt},
+ "kf55": {Code: KeyF7, Mod: ModAlt},
+ "kf56": {Code: KeyF8, Mod: ModAlt},
+ "kf57": {Code: KeyF9, Mod: ModAlt},
+ "kf58": {Code: KeyF10, Mod: ModAlt},
+ "kf59": {Code: KeyF11, Mod: ModAlt},
+ "kf60": {Code: KeyF12, Mod: ModAlt},
+ "kf61": {Code: KeyF1, Mod: ModShift | ModAlt},
+ "kf62": {Code: KeyF2, Mod: ModShift | ModAlt},
+ "kf63": {Code: KeyF3, Mod: ModShift | ModAlt},
+ }
+
+ // Preserve F keys from F13 to F63 instead of using them for F-keys
+ // modifiers.
+ if flags&flagFKeys != 0 {
+ keys["kf13"] = Key{Code: KeyF13}
+ keys["kf14"] = Key{Code: KeyF14}
+ keys["kf15"] = Key{Code: KeyF15}
+ keys["kf16"] = Key{Code: KeyF16}
+ keys["kf17"] = Key{Code: KeyF17}
+ keys["kf18"] = Key{Code: KeyF18}
+ keys["kf19"] = Key{Code: KeyF19}
+ keys["kf20"] = Key{Code: KeyF20}
+ keys["kf21"] = Key{Code: KeyF21}
+ keys["kf22"] = Key{Code: KeyF22}
+ keys["kf23"] = Key{Code: KeyF23}
+ keys["kf24"] = Key{Code: KeyF24}
+ keys["kf25"] = Key{Code: KeyF25}
+ keys["kf26"] = Key{Code: KeyF26}
+ keys["kf27"] = Key{Code: KeyF27}
+ keys["kf28"] = Key{Code: KeyF28}
+ keys["kf29"] = Key{Code: KeyF29}
+ keys["kf30"] = Key{Code: KeyF30}
+ keys["kf31"] = Key{Code: KeyF31}
+ keys["kf32"] = Key{Code: KeyF32}
+ keys["kf33"] = Key{Code: KeyF33}
+ keys["kf34"] = Key{Code: KeyF34}
+ keys["kf35"] = Key{Code: KeyF35}
+ keys["kf36"] = Key{Code: KeyF36}
+ keys["kf37"] = Key{Code: KeyF37}
+ keys["kf38"] = Key{Code: KeyF38}
+ keys["kf39"] = Key{Code: KeyF39}
+ keys["kf40"] = Key{Code: KeyF40}
+ keys["kf41"] = Key{Code: KeyF41}
+ keys["kf42"] = Key{Code: KeyF42}
+ keys["kf43"] = Key{Code: KeyF43}
+ keys["kf44"] = Key{Code: KeyF44}
+ keys["kf45"] = Key{Code: KeyF45}
+ keys["kf46"] = Key{Code: KeyF46}
+ keys["kf47"] = Key{Code: KeyF47}
+ keys["kf48"] = Key{Code: KeyF48}
+ keys["kf49"] = Key{Code: KeyF49}
+ keys["kf50"] = Key{Code: KeyF50}
+ keys["kf51"] = Key{Code: KeyF51}
+ keys["kf52"] = Key{Code: KeyF52}
+ keys["kf53"] = Key{Code: KeyF53}
+ keys["kf54"] = Key{Code: KeyF54}
+ keys["kf55"] = Key{Code: KeyF55}
+ keys["kf56"] = Key{Code: KeyF56}
+ keys["kf57"] = Key{Code: KeyF57}
+ keys["kf58"] = Key{Code: KeyF58}
+ keys["kf59"] = Key{Code: KeyF59}
+ keys["kf60"] = Key{Code: KeyF60}
+ keys["kf61"] = Key{Code: KeyF61}
+ keys["kf62"] = Key{Code: KeyF62}
+ keys["kf63"] = Key{Code: KeyF63}
+ }
+
+ return keys
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/logger.go b/vendor/github.com/charmbracelet/ultraviolet/logger.go
new file mode 100644
index 000000000..abfd86e7a
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/logger.go
@@ -0,0 +1,6 @@
+package uv
+
+// Logger is a simple logger interface.
+type Logger interface {
+ Printf(format string, v ...interface{})
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/mouse.go b/vendor/github.com/charmbracelet/ultraviolet/mouse.go
new file mode 100644
index 000000000..e86d94b8d
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/mouse.go
@@ -0,0 +1,98 @@
+package uv
+
+import (
+ "github.com/charmbracelet/x/ansi"
+)
+
+// MouseMode represents the mouse mode for the terminal. It is used to enable
+// or disable mouse support on the terminal.
+type MouseMode byte
+
+// Mouse modes.
+const (
+ MouseModeNone MouseMode = iota
+ MouseModeClick
+ MouseModeDrag
+ MouseModeMotion
+)
+
+// MouseButton represents the button that was pressed during a mouse message.
+type MouseButton = ansi.MouseButton
+
+// Mouse event buttons
+//
+// This is based on X11 mouse button codes.
+//
+// 1 = left button
+// 2 = middle button (pressing the scroll wheel)
+// 3 = right button
+// 4 = turn scroll wheel up
+// 5 = turn scroll wheel down
+// 6 = push scroll wheel left
+// 7 = push scroll wheel right
+// 8 = 4th button (aka browser backward button)
+// 9 = 5th button (aka browser forward button)
+// 10
+// 11
+//
+// Other buttons are not supported.
+const (
+ MouseNone = ansi.MouseNone
+ MouseLeft = ansi.MouseLeft
+ MouseMiddle = ansi.MouseMiddle
+ MouseRight = ansi.MouseRight
+ MouseWheelUp = ansi.MouseWheelUp
+ MouseWheelDown = ansi.MouseWheelDown
+ MouseWheelLeft = ansi.MouseWheelLeft
+ MouseWheelRight = ansi.MouseWheelRight
+ MouseBackward = ansi.MouseBackward
+ MouseForward = ansi.MouseForward
+ MouseButton10 = ansi.MouseButton10
+ MouseButton11 = ansi.MouseButton11
+)
+
+// Mouse represents a Mouse message. Use [MouseEvent] to represent all mouse
+// messages.
+//
+// The X and Y coordinates are zero-based, with (0,0) being the upper left
+// corner of the terminal.
+//
+// // Catch all mouse events
+// switch Event := Event.(type) {
+// case MouseEvent:
+// m := Event.Mouse()
+// fmt.Println("Mouse event:", m.X, m.Y, m)
+// }
+//
+// // Only catch mouse click events
+// switch Event := Event.(type) {
+// case MouseClickEvent:
+// fmt.Println("Mouse click event:", Event.X, Event.Y, Event)
+// }
+type Mouse struct {
+ X, Y int
+ Button MouseButton
+ Mod KeyMod
+}
+
+// String returns a string representation of the mouse message.
+func (m Mouse) String() (s string) {
+ if m.Mod.Contains(ModCtrl) {
+ s += "ctrl+"
+ }
+ if m.Mod.Contains(ModAlt) {
+ s += "alt+"
+ }
+ if m.Mod.Contains(ModShift) {
+ s += "shift+"
+ }
+
+ str := m.Button.String()
+ if str == "" {
+ s += "unknown"
+ } else if str != "none" { // motion events don't have a button
+ s += str
+ }
+
+ return s
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll.go b/vendor/github.com/charmbracelet/ultraviolet/poll.go
new file mode 100644
index 000000000..209211f58
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll.go
@@ -0,0 +1,38 @@
+package uv
+
+import (
+ "fmt"
+ "time"
+)
+
+// pollReader reads data from an [io.Reader] using different native poll APIs
+// depending on the operating system.
+//
+// On Linux, it uses the epoll API.
+// On Windows, it uses The Windows I/O and Console APIs.
+// On macOS and other BSD-based systems, it will try to use the kqueue API and
+// fall back to Unix select if kqueue is not available (e.g., on TTY).
+// On other Unix-like systems, it uses the select API.
+// On all other systems, it falls back to a simple read loop with a timeout.
+type pollReader interface {
+ // Read reads data from the underlying [io.Reader]. It blocks until data is
+ // available or an error occurs.
+ //
+ // Use [pollReader] to check for data availability before calling Read to
+ // avoid blocking.
+ Read(p []byte) (n int, err error)
+
+ // Poll notifies when data is available to read with the given timeout. Use
+ // a negative duration to wait indefinitely.
+ Poll(timeout time.Duration) (ready bool, err error)
+
+ // Cancel cancels any ongoing poll or read operations. It returns true if
+ // an operation was canceled, false otherwise.
+ Cancel() bool
+
+ // Close closes the reader and releases any resources associated with it.
+ Close() error
+}
+
+// ErrCanceled is returned when a poll or read operation is canceled.
+var ErrCanceled = fmt.Errorf("poll canceled")
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_bsd.go b/vendor/github.com/charmbracelet/ultraviolet/poll_bsd.go
new file mode 100644
index 000000000..947448750
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_bsd.go
@@ -0,0 +1,165 @@
+//go:build darwin || freebsd || netbsd || openbsd || dragonfly
+// +build darwin freebsd netbsd openbsd dragonfly
+
+package uv
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/sys/unix"
+)
+
+// newPollReader creates a new pollReader for the given io.Reader.
+func newPollReader(reader io.Reader) (pollReader, error) {
+ file, ok := reader.(File)
+ if !ok {
+ return newFallbackReader(reader)
+ }
+
+ // kqueue returns instantly when polling /dev/tty so fallback to select
+ if file.Name() == "/dev/tty" {
+ return newSelectPollReader(reader)
+ }
+
+ kQueue, err := unix.Kqueue()
+ if err != nil {
+ return nil, fmt.Errorf("create kqueue: %w", err)
+ }
+
+ r := &kqueueReader{
+ reader: reader,
+ file: file,
+ kQueue: kQueue,
+ }
+
+ r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+ if err != nil {
+ _ = unix.Close(kQueue)
+ return nil, err
+ }
+
+ unix.SetKevent(&r.kQueueEvents[0], int(file.Fd()), unix.EVFILT_READ, unix.EV_ADD)
+ unix.SetKevent(&r.kQueueEvents[1], int(r.cancelSignalReader.Fd()), unix.EVFILT_READ, unix.EV_ADD)
+
+ return r, nil
+}
+
+// kqueueReader implements pollReader using the BSD kqueue API.
+type kqueueReader struct {
+ reader io.Reader
+ file File
+ cancelSignalReader *os.File
+ cancelSignalWriter *os.File
+ kQueue int
+ kQueueEvents [2]unix.Kevent_t
+ mu sync.Mutex
+ canceled bool
+}
+
+// Read reads data from the underlying reader.
+func (r *kqueueReader) Read(p []byte) (int, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return 0, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ return r.reader.Read(p)
+}
+
+// Poll waits for data to be available to read with the given timeout.
+func (r *kqueueReader) Poll(timeout time.Duration) (bool, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return false, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ events := make([]unix.Kevent_t, 1)
+
+ var ts *unix.Timespec
+ if timeout >= 0 {
+ t := unix.NsecToTimespec(timeout.Nanoseconds())
+ ts = &t
+ }
+
+ for {
+ n, err := unix.Kevent(r.kQueue, r.kQueueEvents[:], events, ts)
+ if errors.Is(err, unix.EINTR) {
+ continue // try again if the syscall was interrupted
+ }
+
+ if err != nil {
+ return false, fmt.Errorf("kevent: %w", err)
+ }
+
+ if n == 0 {
+ return false, nil // timeout
+ }
+
+ break
+ }
+
+ ident := uint64(events[0].Ident)
+ switch ident {
+ case uint64(r.file.Fd()):
+ return true, nil
+ case uint64(r.cancelSignalReader.Fd()):
+ // remove signal from pipe
+ var b [1]byte
+ _, errRead := r.cancelSignalReader.Read(b[:])
+ if errRead != nil {
+ return false, fmt.Errorf("reading cancel signal: %w", errRead)
+ }
+ return false, ErrCanceled
+ }
+
+ return false, fmt.Errorf("unknown error")
+}
+
+// Cancel cancels any ongoing poll or read operations.
+func (r *kqueueReader) Cancel() bool {
+ r.mu.Lock()
+ r.canceled = true
+ r.mu.Unlock()
+
+ // send cancel signal
+ _, err := r.cancelSignalWriter.Write([]byte{'c'})
+ return err == nil
+}
+
+// Close closes the reader and releases any resources.
+func (r *kqueueReader) Close() error {
+ var errMsgs []string
+
+ // close kqueue
+ err := unix.Close(r.kQueue)
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing kqueue: %v", err))
+ }
+
+ // close pipe
+ err = r.cancelSignalWriter.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+ }
+
+ err = r.cancelSignalReader.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+ }
+
+ if len(errMsgs) > 0 {
+ return fmt.Errorf("%s", strings.Join(errMsgs, ", "))
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_default.go b/vendor/github.com/charmbracelet/ultraviolet/poll_default.go
new file mode 100644
index 000000000..464c70fb6
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_default.go
@@ -0,0 +1,12 @@
+//go:build !linux && !windows && !darwin && !freebsd && !netbsd && !openbsd && !dragonfly && !solaris
+// +build !linux,!windows,!darwin,!freebsd,!netbsd,!openbsd,!dragonfly,!solaris
+
+package uv
+
+import "io"
+
+// newPollReader creates a new pollReader for the given io.Reader.
+// This is the default implementation for unsupported platforms.
+func newPollReader(reader io.Reader) (pollReader, error) {
+ return newFallbackReader(reader)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_fallback.go b/vendor/github.com/charmbracelet/ultraviolet/poll_fallback.go
new file mode 100644
index 000000000..187a1ed85
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_fallback.go
@@ -0,0 +1,158 @@
+package uv
+
+import (
+ "bufio"
+ "io"
+ "sync"
+ "time"
+)
+
+// newFallbackReader creates a new fallbackReader for the given io.Reader.
+func newFallbackReader(reader io.Reader) (pollReader, error) {
+ return &fallbackReader{
+ reader: bufio.NewReader(reader),
+ cancelChan: make(chan struct{}),
+ dataChan: make(chan struct{}, 1),
+ }, nil
+}
+
+// fallbackReader implements pollReader using goroutines and buffered I/O.
+// This is a fallback implementation that works on all platforms.
+type fallbackReader struct {
+ reader *bufio.Reader
+ cancelChan chan struct{}
+ dataChan chan struct{}
+ mu sync.Mutex
+ canceled bool
+ started bool
+}
+
+// Read reads data from the underlying reader.
+func (r *fallbackReader) Read(p []byte) (int, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return 0, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ n, err := r.reader.Read(p)
+ // If we get an error during a concurrent cancel, prefer ErrCanceled
+ if err != nil {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return 0, ErrCanceled
+ }
+ r.mu.Unlock()
+ }
+ return n, err
+}
+
+// Poll waits for data to be available to read with the given timeout.
+// This implementation starts a background goroutine to check for buffered
+// data availability.
+func (r *fallbackReader) Poll(timeout time.Duration) (bool, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return false, ErrCanceled
+ }
+
+ // Start the background reader goroutine if not already started
+ if !r.started {
+ r.started = true
+ go r.checkBuffered()
+ }
+ r.mu.Unlock()
+
+ if timeout < 0 {
+ // Wait indefinitely
+ select {
+ case <-r.dataChan:
+ // Put it back for next poll/read
+ select {
+ case r.dataChan <- struct{}{}:
+ default:
+ }
+ return true, nil
+ case <-r.cancelChan:
+ return false, ErrCanceled
+ }
+ }
+
+ // Wait with timeout
+ timer := time.NewTimer(timeout)
+ defer timer.Stop()
+
+ select {
+ case <-r.dataChan:
+ // Put it back for next poll/read
+ select {
+ case r.dataChan <- struct{}{}:
+ default:
+ }
+ return true, nil
+ case <-timer.C:
+ return false, nil
+ case <-r.cancelChan:
+ return false, ErrCanceled
+ }
+}
+
+// checkBuffered runs in a background goroutine to signal when data is available.
+func (r *fallbackReader) checkBuffered() {
+ for {
+ select {
+ case <-r.cancelChan:
+ return
+ default:
+ }
+
+ // Check if data is buffered
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return
+ }
+ r.mu.Unlock()
+
+ // Peek at one byte to check if data is available
+ // This will block until data arrives
+ _, err := r.reader.Peek(1)
+ if err != nil {
+ // If error (including EOF), stop the goroutine
+ return
+ }
+
+ // Signal that data is available
+ select {
+ case r.dataChan <- struct{}{}:
+ case <-r.cancelChan:
+ return
+ }
+
+ // Wait a bit before checking again to avoid busy loop
+ time.Sleep(10 * time.Millisecond)
+ }
+}
+
+// Cancel cancels any ongoing poll or read operations.
+func (r *fallbackReader) Cancel() bool {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return false
+ }
+ r.canceled = true
+ r.mu.Unlock()
+
+ close(r.cancelChan)
+ return true
+}
+
+// Close closes the reader and releases any resources.
+func (r *fallbackReader) Close() error {
+ r.Cancel()
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_linux.go b/vendor/github.com/charmbracelet/ultraviolet/poll_linux.go
new file mode 100644
index 000000000..bbe2c9fa4
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_linux.go
@@ -0,0 +1,175 @@
+//go:build linux
+// +build linux
+
+package uv
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "sync"
+ "time"
+
+ "golang.org/x/sys/unix"
+)
+
+// newPollReader creates a new pollReader for the given io.Reader.
+func newPollReader(reader io.Reader) (pollReader, error) {
+ file, ok := reader.(File)
+ if !ok {
+ return newFallbackReader(reader)
+ }
+
+ epoll, err := unix.EpollCreate1(0)
+ if err != nil {
+ return nil, fmt.Errorf("create epoll: %w", err)
+ }
+
+ r := &epollReader{
+ reader: reader,
+ file: file,
+ epoll: epoll,
+ }
+
+ r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+ if err != nil {
+ _ = unix.Close(epoll)
+ return nil, err
+ }
+
+ err = unix.EpollCtl(epoll, unix.EPOLL_CTL_ADD, int(file.Fd()), &unix.EpollEvent{
+ Events: unix.EPOLLIN,
+ Fd: int32(file.Fd()),
+ })
+ if err != nil {
+ _ = unix.Close(epoll)
+ _ = r.cancelSignalReader.Close()
+ _ = r.cancelSignalWriter.Close()
+ return nil, fmt.Errorf("add reader to epoll interest list: %w", err)
+ }
+
+ err = unix.EpollCtl(epoll, unix.EPOLL_CTL_ADD, int(r.cancelSignalReader.Fd()), &unix.EpollEvent{
+ Events: unix.EPOLLIN,
+ Fd: int32(r.cancelSignalReader.Fd()),
+ })
+ if err != nil {
+ _ = unix.Close(epoll)
+ _ = r.cancelSignalReader.Close()
+ _ = r.cancelSignalWriter.Close()
+ return nil, fmt.Errorf("add cancel signal to epoll interest list: %w", err)
+ }
+
+ return r, nil
+}
+
+// epollReader implements pollReader using the Linux epoll API.
+type epollReader struct {
+ reader io.Reader
+ file File
+ cancelSignalReader *os.File
+ cancelSignalWriter *os.File
+ epoll int
+ mu sync.Mutex
+ canceled bool
+}
+
+// Read reads data from the underlying reader.
+func (r *epollReader) Read(p []byte) (int, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return 0, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ return r.reader.Read(p)
+}
+
+// Poll waits for data to be available to read with the given timeout.
+func (r *epollReader) Poll(timeout time.Duration) (bool, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return false, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ events := make([]unix.EpollEvent, 1)
+
+ timeoutMs := -1
+ if timeout >= 0 {
+ timeoutMs = int(timeout.Milliseconds())
+ }
+
+ for {
+ n, err := unix.EpollWait(r.epoll, events, timeoutMs)
+ if errors.Is(err, unix.EINTR) {
+ continue // try again if the syscall was interrupted
+ }
+
+ if err != nil {
+ return false, fmt.Errorf("epoll wait: %w", err)
+ }
+
+ if n == 0 {
+ return false, nil // timeout
+ }
+
+ break
+ }
+
+ switch events[0].Fd {
+ case int32(r.file.Fd()):
+ return true, nil
+ case int32(r.cancelSignalReader.Fd()):
+ // remove signal from pipe
+ var b [1]byte
+ _, readErr := r.cancelSignalReader.Read(b[:])
+ if readErr != nil {
+ return false, fmt.Errorf("reading cancel signal: %w", readErr)
+ }
+ return false, ErrCanceled
+ }
+
+ return false, fmt.Errorf("unknown error")
+}
+
+// Cancel cancels any ongoing poll or read operations.
+func (r *epollReader) Cancel() bool {
+ r.mu.Lock()
+ r.canceled = true
+ r.mu.Unlock()
+
+ // send cancel signal
+ _, err := r.cancelSignalWriter.Write([]byte{'c'})
+ return err == nil
+}
+
+// Close closes the reader and releases any resources.
+func (r *epollReader) Close() error {
+ var errMsgs []error
+
+ // close epoll
+ err := unix.Close(r.epoll)
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Errorf("closing epoll: %w", err))
+ }
+
+ // close pipe
+ err = r.cancelSignalWriter.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Errorf("closing cancel signal writer: %w", err))
+ }
+
+ err = r.cancelSignalReader.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Errorf("closing cancel signal reader: %w", err))
+ }
+
+ if len(errMsgs) > 0 {
+ return errors.Join(errMsgs...)
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_select.go b/vendor/github.com/charmbracelet/ultraviolet/poll_select.go
new file mode 100644
index 000000000..ff7756a14
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_select.go
@@ -0,0 +1,156 @@
+//go:build solaris || darwin || freebsd || netbsd || openbsd || dragonfly
+// +build solaris darwin freebsd netbsd openbsd dragonfly
+
+package uv
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/sys/unix"
+)
+
+// newSelectPollReader creates a new SelectReader for the given io.Reader.
+func newSelectPollReader(reader io.Reader) (pollReader, error) {
+ file, ok := reader.(File)
+ if !ok || file.Fd() >= unix.FD_SETSIZE {
+ return newFallbackReader(reader)
+ }
+
+ r := &selectReader{
+ reader: reader,
+ file: file,
+ }
+
+ var err error
+ r.cancelSignalReader, r.cancelSignalWriter, err = os.Pipe()
+ if err != nil {
+ return nil, err
+ }
+
+ return r, nil
+}
+
+// selectReader implements pollReader using the POSIX select API.
+type selectReader struct {
+ reader io.Reader
+ file File
+ cancelSignalReader *os.File
+ cancelSignalWriter *os.File
+ mu sync.Mutex
+ canceled bool
+}
+
+// Read reads data from the underlying reader.
+func (r *selectReader) Read(p []byte) (int, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return 0, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ return r.reader.Read(p)
+}
+
+// Poll waits for data to be available to read with the given timeout.
+func (r *selectReader) Poll(timeout time.Duration) (bool, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return false, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ for {
+ readerFd := int(r.file.Fd())
+ abortFd := int(r.cancelSignalReader.Fd())
+
+ maxFd := readerFd
+ if abortFd > maxFd {
+ maxFd = abortFd
+ }
+
+ // this is a limitation of the select syscall
+ if maxFd >= unix.FD_SETSIZE {
+ return false, fmt.Errorf("cannot select on file descriptor %d which is larger than %d", maxFd, unix.FD_SETSIZE)
+ }
+
+ fdSet := &unix.FdSet{}
+ fdSet.Set(readerFd)
+ fdSet.Set(abortFd)
+
+ var tv *unix.Timeval
+ if timeout >= 0 {
+ t := unix.NsecToTimeval(timeout.Nanoseconds())
+ tv = &t
+ }
+
+ n, err := unix.Select(maxFd+1, fdSet, nil, nil, tv)
+ if errors.Is(err, unix.EINTR) {
+ continue // try again if the syscall was interrupted
+ }
+
+ if err != nil {
+ return false, fmt.Errorf("select: %w", err)
+ }
+
+ if n == 0 {
+ return false, nil // timeout
+ }
+
+ if fdSet.IsSet(abortFd) {
+ // remove signal from pipe
+ var b [1]byte
+ _, readErr := r.cancelSignalReader.Read(b[:])
+ if readErr != nil {
+ return false, fmt.Errorf("reading cancel signal: %w", readErr)
+ }
+ return false, ErrCanceled
+ }
+
+ if fdSet.IsSet(readerFd) {
+ return true, nil
+ }
+
+ return false, fmt.Errorf("select returned without setting a file descriptor")
+ }
+}
+
+// Cancel cancels any ongoing poll or read operations.
+func (r *selectReader) Cancel() bool {
+ r.mu.Lock()
+ r.canceled = true
+ r.mu.Unlock()
+
+ // send cancel signal
+ _, err := r.cancelSignalWriter.Write([]byte{'c'})
+ return err == nil
+}
+
+// Close closes the reader and releases any resources.
+func (r *selectReader) Close() error {
+ var errMsgs []string
+
+ // close pipe
+ err := r.cancelSignalWriter.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal writer: %v", err))
+ }
+
+ err = r.cancelSignalReader.Close()
+ if err != nil {
+ errMsgs = append(errMsgs, fmt.Sprintf("closing cancel signal reader: %v", err))
+ }
+
+ if len(errMsgs) > 0 {
+ return fmt.Errorf("%s", strings.Join(errMsgs, ", "))
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_solaris.go b/vendor/github.com/charmbracelet/ultraviolet/poll_solaris.go
new file mode 100644
index 000000000..7a753da45
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_solaris.go
@@ -0,0 +1,12 @@
+//go:build solaris
+// +build solaris
+
+package uv
+
+import "io"
+
+// newPollReader creates a new pollReader for the given io.Reader.
+// On Solaris, we use the select API.
+func newPollReader(reader io.Reader) (pollReader, error) {
+ return newSelectPollReader(reader)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/poll_windows.go b/vendor/github.com/charmbracelet/ultraviolet/poll_windows.go
new file mode 100644
index 000000000..2e1922eb2
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/poll_windows.go
@@ -0,0 +1,217 @@
+//go:build windows
+// +build windows
+
+package uv
+
+import (
+ "fmt"
+ "io"
+ "os"
+ "sync"
+ "time"
+
+ "golang.org/x/sys/windows"
+)
+
+var fileShareValidFlags uint32 = windows.FILE_SHARE_DELETE | windows.FILE_SHARE_WRITE | windows.FILE_SHARE_READ
+
+// newPollReader creates a new pollReader for the given io.Reader.
+func newPollReader(reader io.Reader) (pollReader, error) {
+ f, ok := reader.(File)
+ if !ok || f.Fd() != os.Stdin.Fd() {
+ return newFallbackReader(reader)
+ }
+
+ // it is necessary to open CONIN$ (NOT windows.STD_INPUT_HANDLE) in
+ // overlapped mode to be able to use it with WaitForMultipleObjects.
+ coninPath, err := windows.UTF16PtrFromString("CONIN$")
+ if err != nil {
+ return nil, fmt.Errorf("convert CONIN$ to UTF16: %w", err)
+ }
+
+ conin, err := windows.CreateFile(
+ coninPath,
+ windows.GENERIC_READ|windows.GENERIC_WRITE,
+ fileShareValidFlags,
+ nil,
+ windows.OPEN_EXISTING,
+ windows.FILE_FLAG_OVERLAPPED,
+ 0)
+ if err != nil {
+ return nil, fmt.Errorf("open CONIN$ in overlapping mode: %w", err)
+ }
+
+ resetConsole, err := preparePollConsole(conin)
+ if err != nil {
+ _ = windows.CloseHandle(conin)
+ return nil, fmt.Errorf("prepare console: %w", err)
+ }
+
+ // flush input, otherwise it can contain events which trigger
+ // WaitForMultipleObjects but which ReadFile cannot read, resulting in an
+ // un-cancelable read
+ err = windows.FlushConsoleInputBuffer(conin)
+ if err != nil {
+ _ = windows.CloseHandle(conin)
+ return nil, fmt.Errorf("flush console input buffer: %w", err)
+ }
+
+ cancelEvent, err := windows.CreateEvent(nil, 0, 0, nil)
+ if err != nil {
+ _ = windows.CloseHandle(conin)
+ return nil, fmt.Errorf("create cancel event: %w", err)
+ }
+
+ return &conReader{
+ reader: reader,
+ conin: conin,
+ cancelEvent: cancelEvent,
+ resetConsole: resetConsole,
+ blockingReadSignal: make(chan struct{}, 1),
+ }, nil
+}
+
+// conReader implements pollReader using Windows I/O and Console APIs.
+type conReader struct {
+ reader io.Reader
+ conin windows.Handle
+ cancelEvent windows.Handle
+ resetConsole func() error
+ blockingReadSignal chan struct{}
+ mu sync.Mutex
+ canceled bool
+}
+
+// Read reads data from the underlying reader.
+func (r *conReader) Read(p []byte) (int, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return 0, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ return r.reader.Read(p)
+}
+
+// Poll waits for data to be available to read with the given timeout.
+func (r *conReader) Poll(timeout time.Duration) (bool, error) {
+ r.mu.Lock()
+ if r.canceled {
+ r.mu.Unlock()
+ return false, ErrCanceled
+ }
+ r.mu.Unlock()
+
+ timeoutMs := uint32(windows.INFINITE)
+ if timeout >= 0 {
+ timeoutMs = uint32(timeout.Milliseconds())
+ }
+
+ event, err := windows.WaitForMultipleObjects([]windows.Handle{r.conin, r.cancelEvent}, false, timeoutMs)
+ switch {
+ case windows.WAIT_OBJECT_0 <= event && event < windows.WAIT_OBJECT_0+2:
+ if event == windows.WAIT_OBJECT_0+1 {
+ return false, ErrCanceled
+ }
+
+ if event == windows.WAIT_OBJECT_0 {
+ return true, nil
+ }
+
+ return false, fmt.Errorf("unexpected wait object is ready: %d", event-windows.WAIT_OBJECT_0)
+ case windows.WAIT_ABANDONED <= event && event < windows.WAIT_ABANDONED+2:
+ return false, fmt.Errorf("abandoned")
+ case event == uint32(windows.WAIT_TIMEOUT):
+ return false, nil
+ case event == windows.WAIT_FAILED:
+ return false, fmt.Errorf("failed")
+ default:
+ return false, fmt.Errorf("unexpected error: %w", error(err))
+ }
+}
+
+// Cancel cancels any ongoing poll or read operations.
+// On Windows Terminal, WaitForMultipleObjects sometimes immediately returns
+// without input being available. In this case, graceful cancelation is not
+// possible and Cancel() returns false.
+func (r *conReader) Cancel() bool {
+ r.mu.Lock()
+ r.canceled = true
+ r.mu.Unlock()
+
+ select {
+ case r.blockingReadSignal <- struct{}{}:
+ err := windows.SetEvent(r.cancelEvent)
+ if err != nil {
+ return false
+ }
+ <-r.blockingReadSignal
+ case <-time.After(100 * time.Millisecond):
+ // Read() hangs in a GetOverlappedResult which is likely due to
+ // WaitForMultipleObjects returning without input being available
+ // so we cannot cancel this ongoing read.
+ return false
+ }
+
+ return true
+}
+
+// Close closes the reader and releases any resources.
+func (r *conReader) Close() error {
+ err := windows.CloseHandle(r.cancelEvent)
+ if err != nil {
+ return fmt.Errorf("closing cancel event handle: %w", err)
+ }
+
+ err = r.resetConsole()
+ if err != nil {
+ return err
+ }
+
+ err = windows.CloseHandle(r.conin)
+ if err != nil {
+ return fmt.Errorf("closing CONIN$: %w", err)
+ }
+
+ return nil
+}
+
+func preparePollConsole(input windows.Handle) (reset func() error, err error) {
+ var originalMode uint32
+
+ err = windows.GetConsoleMode(input, &originalMode)
+ if err != nil {
+ return nil, fmt.Errorf("get console mode: %w", err)
+ }
+
+ var newMode uint32
+ newMode &^= windows.ENABLE_ECHO_INPUT
+ newMode &^= windows.ENABLE_LINE_INPUT
+ newMode &^= windows.ENABLE_MOUSE_INPUT
+ newMode &^= windows.ENABLE_PROCESSED_INPUT
+
+ newMode |= windows.ENABLE_EXTENDED_FLAGS
+ newMode |= windows.ENABLE_INSERT_MODE
+ newMode |= windows.ENABLE_QUICK_EDIT_MODE
+ newMode |= windows.ENABLE_WINDOW_INPUT // Enable window input events
+
+ // Enabling virtual terminal input is necessary for processing certain
+ // types of input like X10 mouse events and arrows keys with the current
+ // bytes-based input reader.
+ newMode |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
+
+ err = windows.SetConsoleMode(input, newMode)
+ if err != nil {
+ return nil, fmt.Errorf("set console mode: %w", err)
+ }
+
+ return func() error {
+ err := windows.SetConsoleMode(input, originalMode)
+ if err != nil {
+ return fmt.Errorf("reset console mode: %w", err)
+ }
+
+ return nil
+ }, nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/styled.go b/vendor/github.com/charmbracelet/ultraviolet/styled.go
new file mode 100644
index 000000000..540f6463a
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/styled.go
@@ -0,0 +1,337 @@
+package uv
+
+import (
+ "bytes"
+ "image/color"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// StyledString is a string that can be decomposed into a series of styled
+// lines and cells. It is used to disassemble a rendered string with ANSI
+// escape codes into a series of cells that can be used in a [Buffer].
+// A StyledString supports reading [ansi.SGR] and [ansi.Hyperlink] escape
+// codes.
+type StyledString struct {
+ // Text is the original string that was used to create the styled string.
+ Text string
+ // Wrap determines whether the styled string should wrap to the next line.
+ Wrap bool
+ // Tail is the string that will be appended to the end of the line when the
+ // string is truncated i.e. when [StyledString.Wrap] is false.
+ Tail string
+}
+
+var _ Drawable = (*StyledString)(nil)
+
+// NewStyledString creates a new [StyledString] for the given method and styled
+// string. The method is used to calculate the width of each line.
+func NewStyledString(str string) *StyledString {
+ ss := new(StyledString)
+ ss.Text = str
+ return ss
+}
+
+// String returns the text of the styled string.
+//
+// It implements the [fmt.Stringer] interface.
+func (s *StyledString) String() string {
+ return s.Text
+}
+
+// Lines returns the styled string decomposed into a slice of [Line]s.
+func (s *StyledString) Lines(m ansi.Method) []Line {
+ return printString(nil, m, 0, 0, Rectangle{}, s.Text, false, "")
+}
+
+// Draw renders the styled string to the given buffer at the
+// specified area.
+func (s *StyledString) Draw(buf Screen, area Rectangle) {
+ // Clear the area before drawing.
+ for y := area.Min.Y; y < area.Max.Y; y++ {
+ for x := area.Min.X; x < area.Max.X; x++ {
+ buf.SetCell(x, y, nil)
+ }
+ }
+ str := s.Text
+ // We need to normalize newlines "\n" to "\r\n" to emulate a raw terminal
+ // output.
+ str = strings.ReplaceAll(str, "\r\n", "\n")
+ printString(buf, buf.WidthMethod(), area.Min.X, area.Min.Y, area, str, !s.Wrap, s.Tail)
+}
+
+// Height returns the number of lines in the styled string. This is the number
+// of lines that the styled string will occupy when rendered to the screen.
+func (s *StyledString) Height() int {
+ return strings.Count(s.Text, "\n") + 1
+}
+
+// UnicodeWidth returns the cells width of the widest line in the styled string
+// using the [ansi.GraphemeWidth] method.
+func (s *StyledString) UnicodeWidth() int {
+ w, _ := s.widthHeight(ansi.GraphemeWidth)
+ return w
+}
+
+// WcWidth returns the cells width of the widest line in the styled string
+// using the [ansi.WcWidth] method.
+func (s *StyledString) WcWidth() int {
+ w, _ := s.widthHeight(ansi.WcWidth)
+ return w
+}
+
+func (s *StyledString) widthHeight(m ansi.Method) (w, h int) {
+ lines := strings.Split(s.Text, "\n")
+ h = len(lines)
+ for _, l := range lines {
+ w = max(w, m.StringWidth(l))
+ }
+ return
+}
+
+// Bounds returns the minimum area that can contain the whole styled string.
+func (s *StyledString) Bounds() Rectangle {
+ w, h := s.widthHeight(ansi.GraphemeWidth)
+ return Rect(0, 0, w, h)
+}
+
+// printString draws a string starting at the given position. If s is nil, it
+// will build and return a slice of [Line]s instead (unwrapped, ignoring bounds).
+func printString[T []byte | string](
+ s Screen,
+ m WidthMethod,
+ x, y int,
+ bounds Rectangle, str T,
+ truncate bool, tail string,
+) (lines []Line) {
+ p := ansi.GetParser()
+ defer ansi.PutParser(p)
+
+ var tailc Cell
+ if truncate && len(tail) > 0 {
+ tailc = *NewCell(m, tail)
+ }
+
+ decoder := ansi.DecodeSequenceWc[T]
+ if m == ansi.GraphemeWidth {
+ decoder = ansi.DecodeSequence[T]
+ }
+
+ if s == nil {
+ lines = []Line{}
+ }
+
+ var cell Cell
+ var style Style
+ var link Link
+ var state byte
+ for len(str) > 0 {
+ seq, width, n, newState := decoder(str, state, p)
+ switch width {
+ case 1, 2, 3, 4: // wide cells can go up to 4 cells wide
+ cell.Width = width
+ cell.Content = string(seq)
+ cell.Style = style
+ cell.Link = link
+
+ if s == nil {
+ // Building lines: unwrapped, no bounds
+ if y >= len(lines) {
+ lines = append(lines, Line{})
+ }
+ lines[y] = append(lines[y], cell)
+ x += width
+ } else {
+ // Drawing to screen: handle wrapping, truncation, and bounds
+ if !truncate && x+cell.Width > bounds.Max.X && y+1 < bounds.Max.Y {
+ // Wrap the string to the width of the window
+ x = bounds.Min.X
+ y++
+ }
+
+ pos := Pos(x, y)
+ if pos.In(bounds) {
+ if truncate && tailc.Width > 0 && x+cell.Width > bounds.Max.X-tailc.Width {
+ // Truncate the string and append the tail if any.
+ cell = tailc
+ cell.Style = style
+ cell.Link = link
+ s.SetCell(x, y, &cell)
+ x += tailc.Width
+ } else {
+ // Print the cell to the screen
+ s.SetCell(x, y, &cell)
+ x += width
+ }
+ }
+ }
+
+ // Reset cell for next iteration
+ cell = Cell{}
+ default:
+ // Valid sequences always have a non-zero Cmd.
+ // TODO: Handle cursor movement and other sequences
+ switch {
+ case ansi.HasCsiPrefix(seq) && p.Command() == 'm':
+ // SGR - Select Graphic Rendition
+ ReadStyle(p.Params(), &style)
+ case ansi.HasOscPrefix(seq) && p.Command() == 8:
+ // Hyperlinks
+ ReadLink(p.Data(), &link)
+ case ansi.Equal(seq, T("\n")):
+ if s == nil {
+ // When building lines, we need to ensure empty lines are represented.
+ if y >= len(lines) {
+ lines = append(lines, Line{})
+ }
+ }
+ y++
+ // Always treat a NL as CR-LF similar to Termios ONLCR.
+ fallthrough
+ case ansi.Equal(seq, T("\r")):
+ if s == nil {
+ x = 0
+ } else {
+ x = bounds.Min.X
+ }
+ default:
+ cell.Content += string(seq)
+ }
+ }
+
+ // Advance the state and data
+ state = newState
+ str = str[n:]
+
+ if y >= bounds.Max.Y {
+ // We've reached the bottom of the bounds, stop processing further
+ // lines.
+ break
+ }
+ }
+
+ // Make sure to set the last cell if it's not empty.
+ if !cell.IsZero() && s != nil {
+ s.SetCell(x, y, &cell)
+ }
+
+ return lines
+}
+
+// ReadStyle reads a Select Graphic Rendition (SGR) escape sequences from a
+// list of parameters into pen.
+func ReadStyle(params ansi.Params, pen *Style) {
+ if len(params) == 0 {
+ *pen = Style{}
+ return
+ }
+
+ for i := 0; i < len(params); i++ {
+ param, hasMore, _ := params.Param(i, 0)
+ switch param {
+ case 0: // Reset
+ *pen = Style{}
+ case 1: // Bold
+ pen.Attrs |= AttrBold
+ case 2: // Dim/Faint
+ pen.Attrs |= AttrFaint
+ case 3: // Italic
+ pen.Attrs |= AttrItalic
+ case 4: // Underline
+ nextParam, _, ok := params.Param(i+1, 0)
+ if hasMore && ok { // Only accept subparameters i.e. separated by ":"
+ switch nextParam {
+ case 0, 1, 2, 3, 4, 5:
+ i++
+ switch nextParam {
+ case 0: // No Underline
+ pen.Underline = UnderlineStyleNone
+ case 1: // Single Underline
+ pen.Underline = UnderlineStyleSingle
+ case 2: // Double Underline
+ pen.Underline = UnderlineStyleDouble
+ case 3: // Curly Underline
+ pen.Underline = UnderlineStyleCurly
+ case 4: // Dotted Underline
+ pen.Underline = UnderlineStyleDotted
+ case 5: // Dashed Underline
+ pen.Underline = UnderlineStyleDashed
+ }
+ }
+ } else {
+ // Single Underline
+ pen.Underline = UnderlineStyleSingle
+ }
+ case 5: // Slow Blink
+ pen.Attrs |= AttrBlink
+ case 6: // Rapid Blink
+ pen.Attrs |= AttrRapidBlink
+ case 7: // Reverse
+ pen.Attrs |= AttrReverse
+ case 8: // Conceal
+ pen.Attrs |= AttrConceal
+ case 9: // Crossed-out/Strikethrough
+ pen.Attrs |= AttrStrikethrough
+ case 22: // Normal Intensity (not bold or faint)
+ pen.Attrs &^= (AttrBold | AttrFaint)
+ case 23: // Not italic, not Fraktur
+ pen.Attrs &^= AttrItalic
+ case 24: // Not underlined
+ pen.Underline = UnderlineStyleNone
+ case 25: // Blink off
+ pen.Attrs &^= (AttrBlink | AttrRapidBlink)
+ case 27: // Positive (not reverse)
+ pen.Attrs &^= AttrReverse
+ case 28: // Reveal
+ pen.Attrs &^= AttrConceal
+ case 29: // Not crossed out
+ pen.Attrs &^= AttrStrikethrough
+ case 30, 31, 32, 33, 34, 35, 36, 37: // Set foreground
+ pen.Fg = ansi.Black + ansi.BasicColor(param-30) //nolint:gosec
+ case 38: // Set foreground 256 or truecolor
+ var c color.Color
+ n := ansi.ReadStyleColor(params[i:], &c)
+ if n > 0 {
+ pen.Fg = c
+ i += n - 1
+ }
+ case 39: // Default foreground
+ pen.Fg = nil
+ case 40, 41, 42, 43, 44, 45, 46, 47: // Set background
+ pen.Bg = ansi.Black + ansi.BasicColor(param-40) //nolint:gosec
+ case 48: // Set background 256 or truecolor
+ var c color.Color
+ n := ansi.ReadStyleColor(params[i:], &c)
+ if n > 0 {
+ pen.Bg = c
+ i += n - 1
+ }
+ case 49: // Default Background
+ pen.Bg = nil
+ case 58: // Set underline color
+ var c color.Color
+ n := ansi.ReadStyleColor(params[i:], &c)
+ if n > 0 {
+ pen.UnderlineColor = c
+ i += n - 1
+ }
+ case 59: // Default underline color
+ pen.UnderlineColor = nil
+ case 90, 91, 92, 93, 94, 95, 96, 97: // Set bright foreground
+ pen.Fg = ansi.BrightBlack + ansi.BasicColor(param-90) //nolint:gosec
+ case 100, 101, 102, 103, 104, 105, 106, 107: // Set bright background
+ pen.Bg = ansi.BrightBlack + ansi.BasicColor(param-100) //nolint:gosec
+ }
+ }
+}
+
+// ReadLink reads a hyperlink escape sequence from a data buffer into link.
+func ReadLink(p []byte, link *Link) {
+ params := bytes.Split(p, []byte{';'})
+ if len(params) != 3 {
+ return
+ }
+ link.Params = string(params[1])
+ link.URL = string(params[2])
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/tabstop.go b/vendor/github.com/charmbracelet/ultraviolet/tabstop.go
new file mode 100644
index 000000000..ce13814bc
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/tabstop.go
@@ -0,0 +1,142 @@
+package uv
+
+// DefaultTabInterval is the default tab interval.
+const DefaultTabInterval = 8
+
+// TabStops represents horizontal line tab stops.
+type TabStops struct {
+ stops []int
+ interval int
+ width int
+}
+
+// NewTabStops creates a new set of tab stops from a number of columns and an
+// interval.
+func NewTabStops(width, interval int) *TabStops {
+ ts := new(TabStops)
+ ts.interval = interval
+ ts.width = width
+ ts.stops = make([]int, (width+(interval-1))/interval)
+ ts.init(0, width)
+ return ts
+}
+
+// DefaultTabStops creates a new set of tab stops with the default interval.
+func DefaultTabStops(cols int) *TabStops {
+ return NewTabStops(cols, DefaultTabInterval)
+}
+
+// Resize resizes the tab stops to the given width.
+func (ts *TabStops) Resize(width int) {
+ if width == ts.width {
+ return
+ }
+
+ if width < ts.width {
+ size := (width + (ts.interval - 1)) / ts.interval
+ ts.stops = ts.stops[:size]
+ } else {
+ size := (width - ts.width + (ts.interval - 1)) / ts.interval
+ ts.stops = append(ts.stops, make([]int, size)...)
+ }
+
+ ts.init(ts.width, width)
+ ts.width = width
+}
+
+// Width returns the width of the screen that the tab stops are set for.
+func (ts *TabStops) Width() int {
+ return ts.width
+}
+
+// IsStop returns true if the given column is a tab stop.
+func (ts TabStops) IsStop(col int) bool {
+ mask := ts.mask(col)
+ i := col >> 3
+ if i < 0 || i >= len(ts.stops) {
+ return false
+ }
+ return ts.stops[i]&mask != 0
+}
+
+// Next returns the next tab stop after the given column.
+func (ts TabStops) Next(col int) int {
+ return ts.Find(col, 1)
+}
+
+// Prev returns the previous tab stop before the given column.
+func (ts TabStops) Prev(col int) int {
+ return ts.Find(col, -1)
+}
+
+// Find returns the prev/next tab stop before/after the given column and delta.
+// If delta is positive, it returns the next tab stop after the given column.
+// If delta is negative, it returns the previous tab stop before the given column.
+// If delta is zero, it returns the given column.
+func (ts TabStops) Find(col, delta int) int {
+ if delta == 0 {
+ return col
+ }
+
+ var prev bool
+ count := delta
+ if count < 0 {
+ count = -count
+ prev = true
+ }
+
+ for count > 0 {
+ if !prev {
+ if col >= ts.width-1 {
+ return col
+ }
+
+ col++
+ } else {
+ if col < 1 {
+ return col
+ }
+
+ col--
+ }
+
+ if ts.IsStop(col) {
+ count--
+ }
+ }
+
+ return col
+}
+
+// Set adds a tab stop at the given column.
+func (ts *TabStops) Set(col int) {
+ mask := ts.mask(col)
+ ts.stops[col>>3] |= mask
+}
+
+// Reset removes the tab stop at the given column.
+func (ts *TabStops) Reset(col int) {
+ mask := ts.mask(col)
+ ts.stops[col>>3] &= ^mask
+}
+
+// Clear removes all tab stops.
+func (ts *TabStops) Clear() {
+ ts.stops = make([]int, len(ts.stops))
+}
+
+// mask returns the mask for the given column.
+func (ts *TabStops) mask(col int) int {
+ return 1 << (col & (ts.interval - 1))
+}
+
+// init initializes the tab stops starting from col until width.
+func (ts *TabStops) init(col, width int) {
+ for x := col; x < width; x++ {
+ if x%ts.interval == 0 {
+ ts.Set(x)
+ } else {
+ ts.Reset(x)
+ }
+ }
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal.go b/vendor/github.com/charmbracelet/ultraviolet/terminal.go
new file mode 100644
index 000000000..14c735a4d
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal.go
@@ -0,0 +1,350 @@
+package uv
+
+import (
+ "fmt"
+ "os"
+ "os/signal"
+ "time"
+
+ "golang.org/x/sync/errgroup"
+)
+
+// DefaultBufferSize is the default size of the input buffer used for reading
+// terminal events.
+const DefaultBufferSize = 4096
+
+// DefaultEventTimeout is the default duration to wait for input events before
+// timing out.
+const DefaultEventTimeout = 100 * time.Millisecond
+
+// Options represents options for creating a new [Terminal].
+type Options struct {
+ // BufferSize is the size of the input buffer used for reading terminal
+ // events. If zero, [DefaultBufferSize] is used.
+ BufferSize int
+
+ // EventTimeout is the duration to wait for input events before timing out.
+ // If zero, a default of 100 milliseconds is used.
+ EventTimeout time.Duration
+
+ // LegacyKeyEncoding represents any legacy key encoding ambiguities. By
+ // default, the terminal will use its preferred key encoding settings.
+ LegacyKeyEncoding LegacyKeyEncoding
+
+ // LookupKeys whether to use a lookup table for common key sequences. If
+ // true, the terminal will use a lookup table to quickly identify common
+ // key sequences, reducing the need for more complex decoding logic. This
+ // can improve performance for common key sequences at the cost of
+ // increased memory usage.
+ //
+ // This is enabled by default.
+ LookupKeys bool
+
+ // UseTerminfoKeys whether to use terminfo databases key definitions to
+ // build up the keys lookup table. If true, the terminal will use terminfo
+ // databases key definitions to build up the keys lookup table, which can
+ // provide more accurate key mappings for legacy non-xterm like terminals.
+ //
+ // This won't take effect if [TerminalOptions.LookupKeys] is false, since
+ // the lookup table won't be used.
+ //
+ // This is disabled by default.
+ UseTerminfoKeys bool
+}
+
+// DefaultOptions returns the default [Terminal] options.
+func DefaultOptions() *Options {
+ return &Options{
+ BufferSize: DefaultBufferSize,
+ EventTimeout: DefaultEventTimeout,
+ LookupKeys: true,
+ }
+}
+
+// Terminal represents an interactive terminal application.
+type Terminal struct {
+ con Console
+ opts *Options
+ scr *TerminalScreen
+ pr pollReader
+ buf []byte
+ evc chan Event
+ errg errgroup.Group
+ winch chan os.Signal
+ donec chan struct{}
+ logger Logger
+}
+
+// DefaultTerminal creates a new [Terminal] instance using the default standard
+// console and the given options. Options can be nil to use the default
+// options.
+//
+// This is a convenience function for creating a terminal that uses the
+// standard input and output file descriptors.
+func DefaultTerminal() *Terminal {
+ return NewTerminal(nil, nil)
+}
+
+// ControllingTerminal creates a new [Terminal] instance using the controlling
+// terminal's input and output file descriptors.
+// Options can be nil to use the default options.
+//
+// This is a convenience function for creating a terminal that uses the
+// controlling TTY of the current process.
+func ControllingTerminal() (*Terminal, error) {
+ con, err := ControllingConsole()
+ if err != nil {
+ return nil, err
+ }
+ return NewTerminal(con, nil), nil
+}
+
+// NewTerminal creates a new [Terminal] instance with the given console and
+// options.
+// Options can be nil to use the default options.
+func NewTerminal(con Console, opts *Options) *Terminal {
+ t := &Terminal{}
+ if con == nil {
+ con = DefaultConsole()
+ }
+ if opts == nil {
+ opts = DefaultOptions()
+ }
+ if opts.BufferSize <= 0 {
+ opts.BufferSize = DefaultBufferSize
+ }
+ if opts.EventTimeout <= 0 {
+ opts.EventTimeout = DefaultEventTimeout
+ }
+ t.con = con
+ t.opts = opts
+ t.scr = NewTerminalScreen(t.con.Writer(), t.con.Environ())
+ t.buf = make([]byte, opts.BufferSize)
+ // These channels never close during the terminal's lifetime.
+ t.evc = make(chan Event)
+ t.winch = make(chan os.Signal, 1) // buffered to avoid missing signals
+ return t
+}
+
+// SetLogger sets the terminal's logger for tracing I/O operations.
+func (t *Terminal) SetLogger(logger Logger) {
+ t.logger = logger
+ t.scr.rend.SetLogger(logger)
+}
+
+// Screen returns the terminal's screen.
+func (t *Terminal) Screen() *TerminalScreen {
+ return t.scr
+}
+
+// Events returns the terminal's event channel.
+func (t *Terminal) Events() <-chan Event {
+ return t.evc
+}
+
+// Start starts the terminal application event loop. This is a non-blocking
+// call. Use [Terminal.Wait] to wait for the terminal to exit.
+func (t *Terminal) Start() error {
+ _, err := t.con.MakeRaw()
+ if err != nil {
+ return fmt.Errorf("failed to set terminal to raw mode: %w", err)
+ }
+
+ evs := newEventScanner()
+ evs.lookup = t.opts.LookupKeys
+ if evs.lookup {
+ evs.table = buildKeysTable(t.opts.LegacyKeyEncoding, t.con.Getenv("TERM"), t.opts.UseTerminfoKeys)
+ }
+ if t.logger != nil {
+ evs.setLogger(t.logger)
+ }
+ bufc := make(chan []byte)
+ t.donec = make(chan struct{})
+ t.pr, err = newPollReader(t.con.Reader())
+ if err != nil {
+ return fmt.Errorf("failed to create poll reader: %w", err)
+ }
+
+ // input loop
+ t.errg.Go(func() error {
+ for {
+ n, err := t.pr.Read(t.buf)
+ if err != nil {
+ return fmt.Errorf("reading terminal input: %w", err)
+ }
+ select {
+ case bufc <- t.buf[:n]:
+ case <-t.donec:
+ return nil
+ }
+ }
+ })
+
+ // event loop
+ sendEvents := func(buf []byte, expired bool) int {
+ n, events := evs.scanEvents(buf, expired)
+ for _, ev := range events {
+ t.SendEvent(ev)
+ }
+ return n
+ }
+ t.errg.Go(func() error {
+ var buf []byte
+ timer := time.NewTimer(t.opts.EventTimeout)
+ timeout := time.Now().Add(t.opts.EventTimeout)
+
+ for {
+ select {
+ case <-t.donec:
+ return nil
+ case <-timer.C:
+ expired := len(buf) > 0 && time.Now().After(timeout)
+ n := sendEvents(buf, expired)
+ if n > 0 {
+ buf = buf[min(n, len(buf)):]
+ }
+ if len(buf) > 0 {
+ timer.Reset(t.opts.EventTimeout)
+ }
+ case data := <-bufc:
+ buf = append(buf, data...)
+ n := sendEvents(buf, false)
+ timeout = time.Now().Add(t.opts.EventTimeout)
+ timer.Stop()
+ if n > 0 {
+ buf = buf[min(n, len(buf)):]
+ }
+ if len(buf) > 0 {
+ timer.Reset(t.opts.EventTimeout)
+ }
+ }
+ }
+ })
+
+ sendWinsize := func() error {
+ ws, err := t.con.GetWinsize()
+ if err != nil {
+ return fmt.Errorf("getting terminal size: %w", err)
+ }
+ if ws.Col > 0 && ws.Row > 0 {
+ t.SendEvent(WindowSizeEvent{
+ Width: int(ws.Col),
+ Height: int(ws.Row),
+ })
+ }
+ if ws.Xpixel > 0 && ws.Ypixel > 0 {
+ t.SendEvent(PixelSizeEvent{
+ Width: int(ws.Xpixel),
+ Height: int(ws.Ypixel),
+ })
+ }
+ return nil
+ }
+
+ // winch handler
+ NotifyWinch(t.winch)
+ t.errg.Go(func() error {
+ for {
+ select {
+ case <-t.donec:
+ return nil
+ case <-t.winch:
+ if err := sendWinsize(); err != nil {
+ return err
+ }
+ }
+ }
+ })
+
+ // init window size
+ t.errg.Go(func() error {
+ if err := sendWinsize(); err != nil {
+ return err
+ }
+ return nil
+ })
+
+ // Restore any previous screen state.
+ if err := t.scr.Restore(); err != nil {
+ return fmt.Errorf("failed to restore terminal screen: %w", err)
+ }
+ if err := t.scr.Flush(); err != nil {
+ return fmt.Errorf("failed to flush terminal screen: %w", err)
+ }
+
+ return nil
+}
+
+// Wait waits for the terminal event loop to exit and returns any error that
+// occurred.
+func (t *Terminal) Wait() error {
+ if err := t.errg.Wait(); err != nil {
+ return fmt.Errorf("terminal event loop error: %w", err)
+ }
+ return nil
+}
+
+// Stop stops the terminal event loop. It is safe to call Stop without a
+// prior [Terminal.Start], and safe to call Stop multiple times in a row.
+// After Stop returns, [Terminal.Start] may be called again to resume.
+func (t *Terminal) Stop() error {
+ if t.donec != nil {
+ select {
+ case <-t.donec:
+ // Already closed.
+ default:
+ close(t.donec)
+ }
+ }
+ if t.winch != nil {
+ signal.Stop(t.winch)
+ }
+ if t.pr != nil {
+ t.pr.Cancel()
+ _ = t.pr.Close()
+ t.pr = nil
+ }
+ if err := t.scr.Reset(); err != nil {
+ _ = t.scr.Flush()
+ _ = t.con.Restore()
+ return fmt.Errorf("failed to reset terminal screen: %w", err)
+ }
+ if err := t.scr.Flush(); err != nil {
+ _ = t.con.Restore()
+ return fmt.Errorf("failed to flush terminal screen: %w", err)
+ }
+ if err := t.con.Restore(); err != nil {
+ return fmt.Errorf("failed to restore terminal state: %w", err)
+ }
+ return nil
+}
+
+// SendEvent sends an event to the terminal's event channel.
+//
+// This can be used to inject custom events into the terminal's event loop,
+// such as timer events, signals, or application-specific events.
+func (t *Terminal) SendEvent(e Event) {
+ select {
+ case t.evc <- e:
+ case <-t.donec:
+ }
+}
+
+// Write writes data directly to the terminal's console output.
+//
+// This is a low-level operation that bypasses the terminal screen buffering
+// and writes directly to the console output handler, usually [os.Stdout] or
+// the controlling TTY.
+func (t *Terminal) Write(p []byte) (n int, err error) {
+ return t.con.Write(p)
+}
+
+// Read reads data from the terminal's console input.
+//
+// This is a low-level operation that bypasses the terminal event processing
+// and reads directly from the console input handler, usually [os.Stdin] or the
+// controlling TTY. Use this method with caution, as it may interfere with the
+// terminal's event loop and screen management.
+func (t *Terminal) Read(p []byte) (n int, err error) {
+ return t.con.Read(p)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_bsdly.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_bsdly.go
new file mode 100644
index 000000000..6f64e6566
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_bsdly.go
@@ -0,0 +1,10 @@
+//go:build darwin || linux || aix
+// +build darwin linux aix
+
+package uv
+
+import "golang.org/x/sys/unix"
+
+func supportsBackspace(lflag uint64) bool {
+ return lflag&unix.BSDLY == unix.BS0
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_bsdly_other.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_bsdly_other.go
new file mode 100644
index 000000000..24bb50d76
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_bsdly_other.go
@@ -0,0 +1,8 @@
+//go:build !darwin && !linux && !aix && !windows
+// +build !darwin,!linux,!aix,!windows
+
+package uv
+
+func supportsBackspace(uint64) bool {
+ return false
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_other.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_other.go
new file mode 100644
index 000000000..9130fcc4c
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_other.go
@@ -0,0 +1,22 @@
+//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !aix && !windows
+// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris,!aix,!windows
+
+package uv
+
+import "github.com/charmbracelet/x/term"
+
+func makeRaw(_, _ term.File) (inTtyState, outTtyState *term.State, err error) {
+ return nil, nil, ErrPlatformNotSupported
+}
+
+func getSize(_, _ term.File) (w, h int, err error) {
+ return 0, 0, ErrPlatformNotSupported
+}
+
+func getWinsize(_, _ term.File) (ws Winsize, err error) {
+ return Winsize{}, ErrPlatformNotSupported
+}
+
+func optimizeMovements(*term.State) (useTabs, useBspace bool) {
+ return false, false
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_reader.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_reader.go
new file mode 100644
index 000000000..b3b79cd00
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_reader.go
@@ -0,0 +1,503 @@
+package uv
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+ "unicode"
+ "unicode/utf16"
+ "unicode/utf8"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/muesli/cancelreader"
+ "github.com/rivo/uniseg"
+)
+
+// ErrReaderNotStarted is returned when the reader has not been started yet.
+var ErrReaderNotStarted = fmt.Errorf("reader not started")
+
+// DefaultEscTimeout is the default timeout at which the [TerminalReader] will
+// process ESC sequences. It is set to 50 milliseconds.
+const DefaultEscTimeout = 50 * time.Millisecond
+
+// TerminalReader represents an input event loop that reads input events from
+// a reader and parses them into human-readable events. It supports
+// reading escape sequences, mouse events, and bracketed paste mode.
+type TerminalReader struct {
+ EventDecoder
+
+ // MouseMode determines whether mouse events are enabled or not. This is a
+ // platform-specific feature and is only available on Windows. When this is
+ // true, the reader will be initialized to read mouse events using the
+ // Windows Console API.
+ MouseMode *MouseMode
+
+ // EscTimeout is the escape character timeout duration. Most escape
+ // sequences start with an escape character [ansi.ESC] and are followed by
+ // one or more characters. If the next character is not received within
+ // this timeout, the reader will assume that the escape sequence is
+ // complete and will process the received characters as a complete escape
+ // sequence.
+ //
+ // By default, this is set to [DefaultEscTimeout] (50 milliseconds).
+ EscTimeout time.Duration
+
+ r io.Reader
+ table map[string]Key // table is a lookup table for key sequences.
+
+ term string // term is the terminal name $TERM.
+
+ // paste is the bracketed paste mode buffer.
+ // When nil, bracketed paste mode is disabled.
+ paste []byte
+
+ lookup bool // lookup indicates whether to use the lookup table for key sequences.
+
+ // vtInput indicates whether we're using Windows Console API VT input mode.
+ //nolint:unused,nolintlint
+ vtInput bool
+
+ eventScanner *eventScanner
+
+ // We use these buffers to decode UTF-16 sequences and graphemes from the
+ // Windows Console API and Win32-Input-Mode events.
+ utf16Half [2]bool // 0 key up, 1 key down
+ utf16Buf [2][2]rune // 0 key up, 1 key down
+ graphemeBuf [2][]rune // 0 key up, 1 key down
+ //nolint:unused,nolintlint
+ lastMouseBtns uint32 // the last mouse button state for the previous event
+ //nolint:unused,nolintlint
+ lastWinsizeX, lastWinsizeY int16 // the last window size for the previous event to prevent multiple size events from firing
+
+ logger Logger // The logger to use for debugging.
+}
+
+// NewTerminalReader returns a new input event reader. The reader streams input
+// events from the terminal and parses escape sequences into human-readable
+// events. It supports reading Terminfo databases.
+//
+// Use [TerminalReader.UseTerminfo] to use Terminfo defined key sequences.
+// Use [TerminalReader.Legacy] to control legacy key encoding behavior.
+//
+// Example:
+//
+// ```go
+// var cr cancelreader.CancelReader
+// var evc chan Event
+// sc := NewTerminalReader(cr, os.Getenv("TERM"))
+// go sc.StreamEvents(ctx, evc)
+// ```
+func NewTerminalReader(r io.Reader, termType string) *TerminalReader {
+ d := &TerminalReader{
+ EscTimeout: DefaultEscTimeout,
+ r: r,
+ term: termType,
+ lookup: true, // Use lookup table by default.
+ }
+ d.r = r
+ if d.table == nil {
+ d.table = buildKeysTable(d.Legacy, d.term, d.UseTerminfo)
+ }
+ evs := newEventScanner()
+ evs.EventDecoder = d.EventDecoder
+ evs.table = d.table
+ evs.lookup = d.lookup
+ evs.setLogger(d.logger)
+ d.eventScanner = evs
+ return d
+}
+
+// readBufSize is the size of the read buffer used to read input events at a time.
+const readBufSize = 4096
+
+// sendBytes reads data from the reader and sends it to the provided channel.
+// It stops when an error occurs or when the context is closed.
+func (d *TerminalReader) sendBytes(ctx context.Context, readc chan []byte) error {
+ for {
+ var readBuf [readBufSize]byte
+ n, err := d.r.Read(readBuf[:])
+ if err != nil {
+ return err //nolint:wrapcheck
+ }
+
+ select {
+ case <-ctx.Done():
+ return nil
+ case readc <- readBuf[:n]:
+ }
+ }
+}
+
+// StreamEvents sends events to the provided channel. It stops when the context
+// is closed or when an error occurs.
+func (d *TerminalReader) StreamEvents(ctx context.Context, eventc chan<- Event) error {
+ var buf bytes.Buffer
+ errc := make(chan error, 1)
+ readc := make(chan []byte)
+ timeout := time.NewTimer(d.EscTimeout)
+ ttimeout := time.Now().Add(d.EscTimeout)
+
+ var wg sync.WaitGroup
+ wg.Add(1)
+
+ go func() {
+ defer wg.Done()
+ if err := d.streamData(ctx, readc); err != nil {
+ if errors.Is(err, io.EOF) || errors.Is(err, cancelreader.ErrCanceled) {
+ errc <- nil
+ return
+ }
+ errc <- err
+ return
+ }
+ }()
+
+ for {
+ select {
+ case <-ctx.Done():
+ d.sendEvents(eventc, buf.Bytes(), true)
+ wg.Wait()
+ return nil
+ case err := <-errc:
+ d.sendEvents(eventc, buf.Bytes(), true)
+ wg.Wait()
+ return err // return the first error encountered
+ case <-timeout.C:
+ d.logf("timeout reached")
+
+ // Timeout reached process the buffer including any incomplete sequences.
+ var n int // n is the number of bytes processed
+ timedout := time.Now().After(ttimeout)
+ if buf.Len() > 0 && timedout {
+ d.logf("timeout expired, processing buffer")
+ n = d.sendEvents(eventc, buf.Bytes(), true)
+ }
+
+ if n > 0 {
+ buf.Next(n)
+ }
+
+ if buf.Len() > 0 {
+ if !timeout.Stop() {
+ // drain the channel if it was already running
+ select {
+ case <-timeout.C:
+ default:
+ }
+ }
+
+ d.logf("resetting timeout for remaining buffer")
+ timeout.Reset(d.EscTimeout)
+ }
+
+ case read := <-readc:
+ d.logf("input: %q", read)
+ buf.Write(read)
+ ttimeout = time.Now().Add(d.EscTimeout)
+ n := d.sendEvents(eventc, buf.Bytes(), false)
+ if !timeout.Stop() {
+ // drain the channel if it was already running
+ select {
+ case <-timeout.C:
+ default:
+ }
+ }
+
+ if n > 0 {
+ d.logf("processed %d bytes from buffer", n)
+ buf.Next(n)
+ }
+
+ if buf.Len() > 0 {
+ d.logf("resetting timeout for remaining buffer after parse")
+ timeout.Reset(d.EscTimeout)
+ }
+ }
+ }
+}
+
+// SetLogger sets the logger to use for debugging. If nil, no logging will be
+// performed.
+func (d *TerminalReader) SetLogger(logger Logger) {
+ d.logger = logger
+}
+
+func (d *TerminalReader) sendEvents(eventc chan<- Event, buf []byte, expired bool) int {
+ n, events := d.eventScanner.scanEvents(buf, expired)
+ for _, event := range events {
+ eventc <- event
+ }
+ return n
+}
+
+// eventScanner scans the buffer for events and sends them to the event channel.
+type eventScanner struct {
+ EventDecoder
+
+ utf16Half [2]bool // 0 key up, 1 key down
+ utf16Buf [2][2]rune // 0 key up, 1 key down
+ graphemeBuf [2][]rune // 0 key up, 1 key down
+ paste []byte
+ table map[string]Key
+ lookup bool
+ logger Logger
+}
+
+// newEventScanner creates a new event scanner.
+func newEventScanner() *eventScanner {
+ return &eventScanner{}
+}
+
+// setLogger sets the logger to use for debugging. If nil, no logging will be
+// performed.
+func (d *eventScanner) setLogger(logger Logger) {
+ d.logger = logger
+}
+
+func (d *eventScanner) logf(format string, v ...interface{}) {
+ logf(d.logger, format, v...)
+}
+
+func (d *eventScanner) scanEvents(buf []byte, expired bool) (total int, events []Event) {
+ if len(buf) == 0 {
+ return 0, nil
+ }
+
+ var dn int
+ d.logf("processing buf %d %q", len(buf), buf)
+ dn, buf = d.deserializeWin32Input(buf)
+ total += dn
+
+ // Lookup table first
+ if d.lookup && len(buf) > 2 && buf[0] == ansi.ESC {
+ if k, ok := d.table[string(buf)]; ok {
+ return len(buf), []Event{KeyPressEvent(k)}
+ }
+ }
+
+ // total is the total number of bytes processed
+ for len(buf) > 0 {
+ esc := buf[0] == ansi.ESC
+ n, event := d.Decode(buf)
+
+ // Handle bracketed-paste
+ if d.paste != nil { //nolint:nestif
+ if _, ok := event.(PasteEndEvent); !ok {
+ switch event := event.(type) {
+ case KeyPressEvent:
+ if len(event.Text) > 0 {
+ d.paste = append(d.paste, event.Text...)
+ } else {
+ seq := string(buf[:n])
+ isWin32 := strings.HasPrefix(seq, "\x1b[") && strings.HasSuffix(seq, "_")
+ switch {
+ case isWin32 && event.Code == KeyEnter && event.Code == event.BaseCode:
+ // This handles special cases where
+ // win32-input-mode encodes newlines and other keys
+ // as keypress events. We need to encode them as
+ // their respective values.
+ d.paste = append(d.paste, '\n')
+ case isWin32 && unicode.IsControl(event.Code) && event.Code == event.BaseCode:
+ // This handles other cases such as tabs, escapes, etc.
+ d.paste = append(d.paste, string(event.Code)...)
+ case !isWin32:
+ // We ignore all other non-text win32-input-mode events.
+ if esc && n <= 2 && !expired {
+ // If the event is an escape sequence and we
+ // are not expired, we need to wait for more
+ // input.
+ return total, events
+ }
+ d.paste = append(d.paste, seq...)
+ }
+ }
+ case UnknownEvent:
+ if !expired {
+ // If the event is unknown and we are not expired, we
+ // return need to try to decode the buffer again.
+ return total, events
+ }
+ default:
+ // Everything else is ignored...
+ }
+ buf = buf[n:]
+ total += n
+ continue
+ }
+ }
+
+ var isUnknown bool
+ switch event.(type) {
+ case ignoredEvent:
+ // ignore this event
+ event = nil
+ case UnknownEvent:
+ isUnknown = true
+ // Try to look up the event in the table.
+ if !expired {
+ return total, events
+ }
+
+ if k, ok := d.table[string(buf[:n])]; ok {
+ events = append(events, KeyPressEvent(k))
+ return total + n, events
+ }
+
+ events = append(events, event)
+ case PasteStartEvent:
+ d.paste = []byte{} // reset the paste buffer
+ case PasteEndEvent:
+ var paste []rune
+ for len(d.paste) > 0 {
+ r, w := utf8.DecodeRune(d.paste)
+ if r != utf8.RuneError {
+ paste = append(paste, r)
+ }
+ d.paste = d.paste[w:]
+ }
+ d.paste = nil // reset the paste buffer
+ events = append(events, PasteEvent{string(paste)})
+ }
+
+ if !isUnknown && event != nil {
+ if esc && n <= 2 && !expired {
+ // Wait for more input
+ return total, events
+ }
+
+ if m, ok := event.(MultiEvent); ok {
+ // If the event is a MultiEvent, append all events to the queue.
+ events = append(events, m...)
+ } else {
+ // Otherwise, just append the event to the queue.
+ events = append(events, event)
+ }
+ }
+
+ buf = buf[n:]
+ total += n
+ }
+
+ return total, events
+}
+
+func (d *eventScanner) encodeGraphemeBufs() []byte {
+ var b []byte
+ for kd := range d.graphemeBuf {
+ if len(d.graphemeBuf[kd]) > 0 {
+ switch kd {
+ case 1:
+ b = append(b, string(d.graphemeBuf[kd])...)
+ case 0:
+ // Encode the release grapheme as Kitty Keyboard to get the release event.
+ grs := uniseg.NewGraphemes(string(d.graphemeBuf[kd]))
+ for grs.Next() {
+ var codepoints string
+ gr := grs.Str()
+ for i, r := range gr {
+ if r == 0 {
+ continue
+ }
+ if i > 0 {
+ codepoints += ":"
+ }
+ codepoints += strconv.FormatInt(int64(r), 10)
+ }
+ // This is dark :)
+ // During serializing/deserializing of win32 input events, the
+ // API will split a grapheme into runes and send them as a
+ // keydown/keyup sequences. We collect the runes, decoded them
+ // from UTF-16 just fine. However, [EventDecoder.Decode] will
+ // always decode graphemes as [KeyPressEvent]s. Thus, to
+ // workaround that and the existing API, while we are
+ // intercepting win32 input events, we encode the grapheme
+ // release events as Kitty Keyboard sequences so that
+ // [EventDecoder.Decode] can properly decode them as
+ // [KeyReleaseEvent]s.
+ seq := fmt.Sprintf("\x1b[%d;1:3;%su", d.graphemeBuf[kd][0], codepoints)
+ b = append(b, seq...)
+ }
+ }
+ d.graphemeBuf[kd] = d.graphemeBuf[kd][:0] // reset the buffer
+ }
+ }
+ return b
+}
+
+func (d *eventScanner) storeGraphemeRune(kd int, r rune) {
+ if d.utf16Half[kd] {
+ // We have a half pair that needs to be decoded.
+ d.utf16Half[kd] = false
+ d.utf16Buf[kd][1] = r
+ r := utf16.DecodeRune(d.utf16Buf[kd][0], d.utf16Buf[kd][1])
+ d.graphemeBuf[kd] = append(d.graphemeBuf[kd], r)
+ } else if utf16.IsSurrogate(r) {
+ // This is the first half of a UTF-16 surrogate pair.
+ d.utf16Half[kd] = true
+ d.utf16Buf[kd][0] = r
+ } else {
+ // This should be a single UTF-16 that can be converted
+ // to UTF-8.
+ d.graphemeBuf[kd] = append(d.graphemeBuf[kd], r)
+ }
+}
+
+// deserializeWin32Input deserializes the Win32 input events converting
+// KeyEventRecrods to bytes. Before returning the bytes, it will also try to
+// decode any UTF-16 pairs that might be present in the input buffer.
+func (d *eventScanner) deserializeWin32Input(buf []byte) (int, []byte) {
+ p := ansi.GetParser()
+ defer ansi.PutParser(p)
+
+ var processed int
+ var state byte
+ des := make([]byte, 0, len(buf))
+
+ for len(buf) > 0 {
+ seq, width, n, newState := ansi.DecodeSequence(buf, state, p)
+ switch width {
+ case 0:
+ if p.Command() == '_' { // Win32 Input Mode
+ vk, _ := p.Param(0, 0)
+ if vk == 0 {
+ // This is either a serialized KeyEventRecord or a UTF-16
+ // pair.
+ uc, _ := p.Param(2, 0)
+ kd, _ := p.Param(3, 0)
+ kd = clamp(kd, 0, 1) // kd is the key down state (0 or 1)
+ d.storeGraphemeRune(kd, rune(uc))
+ processed += n
+ break
+ }
+ }
+ fallthrough
+ default:
+ des = append(des, d.encodeGraphemeBufs()...)
+ des = append(des, seq...)
+ }
+
+ state = newState
+ buf = buf[n:]
+ }
+
+ des = append(des, d.encodeGraphemeBufs()...)
+
+ return processed, des
+}
+
+func (d *TerminalReader) logf(format string, v ...interface{}) {
+ logf(d.logger, format, v...)
+}
+
+func logf(logger Logger, format string, v ...interface{}) {
+ if logger == nil {
+ return
+ }
+ logger.Printf(format, v...)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_reader_other.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_reader_other.go
new file mode 100644
index 000000000..ca2e9e724
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_reader_other.go
@@ -0,0 +1,13 @@
+//go:build !windows
+// +build !windows
+
+package uv
+
+import (
+ "context"
+)
+
+// streamData sends data from the input stream to the event channel.
+func (d *TerminalReader) streamData(ctx context.Context, readc chan []byte) error {
+ return d.sendBytes(ctx, readc)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_reader_windows.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_reader_windows.go
new file mode 100644
index 000000000..119dae172
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_reader_windows.go
@@ -0,0 +1,336 @@
+//go:build windows
+// +build windows
+
+package uv
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "strings"
+ "time"
+ "unicode/utf16"
+
+ "github.com/charmbracelet/x/ansi"
+ xwindows "github.com/charmbracelet/x/windows"
+ "github.com/muesli/cancelreader"
+ "golang.org/x/sys/windows"
+)
+
+// streamData sends data from the input stream to the event channel.
+func (d *TerminalReader) streamData(ctx context.Context, readc chan []byte) error {
+ cc, ok := d.r.(*conInputReader)
+ if !ok {
+ d.logf("streamData: reader is not a conInputReader, falling back to default implementation")
+ return d.sendBytes(ctx, readc)
+ }
+
+ // Store the value of VT Input Mode for later use.
+ d.vtInput = cc.newMode&windows.ENABLE_VIRTUAL_TERMINAL_INPUT != 0
+
+ var buf bytes.Buffer
+ var records []xwindows.InputRecord
+ var err error
+ for {
+ for {
+ records, err = peekNConsoleInputs(cc.conin, readBufSize)
+ if cc.isCanceled() {
+ return cancelreader.ErrCanceled
+ }
+ if err != nil {
+ return err
+ }
+ if len(records) > 0 {
+ break
+ }
+
+ // Sleep for a bit to avoid busy waiting.
+ time.Sleep(10 * time.Millisecond)
+ }
+
+ records, err = readNConsoleInputs(cc.conin, uint32(len(records))) //nolint:gosec
+ if cc.isCanceled() {
+ return cancelreader.ErrCanceled
+ }
+ if err != nil {
+ return err
+ }
+
+ // We convert Windows Input Records to VT input sequences for easier
+ // processing especially when dealing with UTF-16 decoding and
+ // Win32-Input-Mode processing.
+ d.serializeWin32InputRecords(records, &buf)
+
+ select {
+ case <-ctx.Done():
+ return nil
+ case readc <- buf.Bytes():
+ }
+
+ buf.Reset()
+ }
+}
+
+// serializeWin32InputRecords serializes the Win32 input events converting them
+// to valid VT input sequences. It will also encode any UTF-16 pairs that might
+// be present in the input buffer. The resulting byte slice can be sent to the
+// terminal as input.
+func (d *TerminalReader) serializeWin32InputRecords(records []xwindows.InputRecord, buf *bytes.Buffer) {
+ for _, record := range records {
+ switch record.EventType {
+ case xwindows.KEY_EVENT:
+ kevent := record.KeyEvent()
+ // d.logf("key event: %s", keyEventString(kevent.VirtualKeyCode, kevent.VirtualScanCode, kevent.Char, kevent.KeyDown, kevent.ControlKeyState, kevent.RepeatCount))
+
+ var kd int
+ if kevent.KeyDown {
+ kd = 1
+ }
+ if d.vtInput { //nolint:nestif
+ // In VT Input Mode, we only capture the Unicode characters
+ // decoding them along the way.
+ // This is similar to [TerminalReader.storeGraphemeRune] except
+ // that we need to write the events directly to the buffer.
+ if d.utf16Half[kd] {
+ // We have a half pair that needs to be decoded.
+ d.utf16Half[kd] = false
+ d.utf16Buf[kd][1] = kevent.Char
+ r := utf16.DecodeRune(d.utf16Buf[kd][0], d.utf16Buf[kd][1])
+ buf.WriteRune(r)
+ } else if utf16.IsSurrogate(kevent.Char) {
+ // This is the first half of a UTF-16 surrogate pair.
+ d.utf16Half[kd] = true
+ d.utf16Buf[kd][0] = kevent.Char
+ } else if kevent.KeyDown {
+ // Just a regular key press character encoded in VT.
+ buf.WriteRune(kevent.Char)
+ }
+ } else {
+ // We encode the key to Win32 Input Mode if it is a known key.
+ if kevent.VirtualKeyCode == 0 {
+ d.eventScanner.storeGraphemeRune(kd, kevent.Char)
+ } else {
+ buf.Write(d.eventScanner.encodeGraphemeBufs())
+ fmt.Fprintf(buf,
+ "\x1b[%d;%d;%d;%d;%d;%d_",
+ kevent.VirtualKeyCode,
+ kevent.VirtualScanCode,
+ kevent.Char,
+ kd,
+ kevent.ControlKeyState,
+ kevent.RepeatCount)
+ }
+ }
+
+ case xwindows.MOUSE_EVENT:
+ if d.MouseMode == nil || *d.MouseMode == 0 {
+ continue
+ }
+ mouseMode := *d.MouseMode
+ mevent := record.MouseEvent()
+
+ var isRelease bool
+ var isMotion bool
+ var button MouseButton
+ alt := mevent.ControlKeyState&(xwindows.LEFT_ALT_PRESSED|xwindows.RIGHT_ALT_PRESSED) != 0
+ ctrl := mevent.ControlKeyState&(xwindows.LEFT_CTRL_PRESSED|xwindows.RIGHT_CTRL_PRESSED) != 0
+ shift := mevent.ControlKeyState&(xwindows.SHIFT_PRESSED) != 0
+ wheelDirection := int16(highWord(mevent.ButtonState)) //nolint:gosec
+ switch mevent.EventFlags {
+ case 0, xwindows.DOUBLE_CLICK:
+ button, isRelease = mouseEventButton(d.lastMouseBtns, mevent.ButtonState)
+ case xwindows.MOUSE_WHEELED:
+ if wheelDirection > 0 {
+ button = MouseWheelUp
+ } else {
+ button = MouseWheelDown
+ }
+ case xwindows.MOUSE_HWHEELED:
+ if wheelDirection > 0 {
+ button = MouseWheelRight
+ } else {
+ button = MouseWheelLeft
+ }
+ case xwindows.MOUSE_MOVED:
+ button, _ = mouseEventButton(d.lastMouseBtns, mevent.ButtonState)
+ isMotion = true
+ }
+
+ // We emulate mouse mode levels on Windows. This is because Windows
+ // doesn't have a concept of different mouse modes. We use the mouse mode to determine
+ if button == MouseNone && mouseMode&MouseModeMotion == 0 ||
+ (button != MouseNone && mouseMode&MouseModeDrag == 0) {
+ continue
+ }
+
+ // Encode mouse events as SGR mouse sequences that can be read by [EventDecoder].
+ buf.WriteString(ansi.MouseSgr(
+ ansi.EncodeMouseButton(button, isMotion, shift, alt, ctrl),
+ int(mevent.MousePositon.X), int(mevent.MousePositon.Y), isRelease,
+ ))
+
+ d.lastMouseBtns = mevent.ButtonState
+
+ case xwindows.WINDOW_BUFFER_SIZE_EVENT:
+ wevent := record.WindowBufferSizeEvent()
+ if wevent.Size.X != d.lastWinsizeX || wevent.Size.Y != d.lastWinsizeY {
+ d.lastWinsizeX, d.lastWinsizeY = wevent.Size.X, wevent.Size.Y
+ // We encode window resize events as CSI 4 ; height ; width t
+ // sequence which the [EventDecoder] understands.
+ buf.WriteString(
+ ansi.WindowOp(
+ 8, // Terminal window size in cells
+ int(wevent.Size.Y), // height
+ int(wevent.Size.X), // width
+ ),
+ )
+ }
+
+ case xwindows.FOCUS_EVENT:
+ fevent := record.FocusEvent()
+ if fevent.SetFocus {
+ buf.WriteString(ansi.Focus)
+ } else {
+ buf.WriteString(ansi.Blur)
+ }
+
+ case xwindows.MENU_EVENT:
+ // ignore
+ }
+ }
+
+ // Flush any remaining grapheme buffers.
+ buf.Write(d.eventScanner.encodeGraphemeBufs())
+}
+
+func mouseEventButton(p, s uint32) (MouseButton, bool) {
+ var isRelease bool
+ button := MouseNone
+ btn := p ^ s
+ if btn&s == 0 {
+ isRelease = true
+ }
+
+ if btn == 0 {
+ switch {
+ case s&xwindows.FROM_LEFT_1ST_BUTTON_PRESSED > 0:
+ button = MouseLeft
+ case s&xwindows.FROM_LEFT_2ND_BUTTON_PRESSED > 0:
+ button = MouseMiddle
+ case s&xwindows.RIGHTMOST_BUTTON_PRESSED > 0:
+ button = MouseRight
+ case s&xwindows.FROM_LEFT_3RD_BUTTON_PRESSED > 0:
+ button = MouseBackward
+ case s&xwindows.FROM_LEFT_4TH_BUTTON_PRESSED > 0:
+ button = MouseForward
+ }
+ return button, isRelease
+ }
+
+ switch btn {
+ case xwindows.FROM_LEFT_1ST_BUTTON_PRESSED: // left button
+ button = MouseLeft
+ case xwindows.RIGHTMOST_BUTTON_PRESSED: // right button
+ button = MouseRight
+ case xwindows.FROM_LEFT_2ND_BUTTON_PRESSED: // middle button
+ button = MouseMiddle
+ case xwindows.FROM_LEFT_3RD_BUTTON_PRESSED: // unknown (possibly mouse backward)
+ button = MouseBackward
+ case xwindows.FROM_LEFT_4TH_BUTTON_PRESSED: // unknown (possibly mouse forward)
+ button = MouseForward
+ }
+
+ return button, isRelease
+}
+
+func highWord(data uint32) uint16 {
+ return uint16((data & 0xFFFF0000) >> 16) //nolint:gosec
+}
+
+func readNConsoleInputs(console windows.Handle, maxEvents uint32) ([]xwindows.InputRecord, error) {
+ if maxEvents == 0 {
+ return nil, fmt.Errorf("maxEvents cannot be zero")
+ }
+
+ records := make([]xwindows.InputRecord, maxEvents)
+ n, err := readConsoleInput(console, records)
+ return records[:n], err
+}
+
+func readConsoleInput(console windows.Handle, inputRecords []xwindows.InputRecord) (uint32, error) {
+ if len(inputRecords) == 0 {
+ return 0, fmt.Errorf("size of input record buffer cannot be zero")
+ }
+
+ var read uint32
+
+ err := xwindows.ReadConsoleInput(console, &inputRecords[0], uint32(len(inputRecords)), &read) //nolint:gosec
+
+ return read, err //nolint:wrapcheck
+}
+
+func peekConsoleInput(console windows.Handle, inputRecords []xwindows.InputRecord) (uint32, error) {
+ if len(inputRecords) == 0 {
+ return 0, fmt.Errorf("size of input record buffer cannot be zero")
+ }
+
+ var read uint32
+
+ err := xwindows.PeekConsoleInput(console, &inputRecords[0], uint32(len(inputRecords)), &read) //nolint:gosec
+
+ return read, err //nolint:wrapcheck
+}
+
+func peekNConsoleInputs(console windows.Handle, maxEvents uint32) ([]xwindows.InputRecord, error) {
+ if maxEvents == 0 {
+ return nil, fmt.Errorf("maxEvents cannot be zero")
+ }
+
+ records := make([]xwindows.InputRecord, maxEvents)
+ n, err := peekConsoleInput(console, records)
+ return records[:n], err
+}
+
+//nolint:unused
+func keyEventString(vkc, sc uint16, r rune, keyDown bool, cks uint32, repeatCount uint16) string {
+ var s strings.Builder
+ s.WriteString("vkc: ")
+ s.WriteString(fmt.Sprintf("%d, 0x%02x", vkc, vkc))
+ s.WriteString(", sc: ")
+ s.WriteString(fmt.Sprintf("%d, 0x%02x", sc, sc))
+ s.WriteString(", r: ")
+ s.WriteString(fmt.Sprintf("%q 0x%x", r, r))
+ s.WriteString(", down: ")
+ s.WriteString(fmt.Sprintf("%v", keyDown))
+ s.WriteString(", cks: [")
+ if cks&xwindows.LEFT_ALT_PRESSED != 0 {
+ s.WriteString("left alt, ")
+ }
+ if cks&xwindows.RIGHT_ALT_PRESSED != 0 {
+ s.WriteString("right alt, ")
+ }
+ if cks&xwindows.LEFT_CTRL_PRESSED != 0 {
+ s.WriteString("left ctrl, ")
+ }
+ if cks&xwindows.RIGHT_CTRL_PRESSED != 0 {
+ s.WriteString("right ctrl, ")
+ }
+ if cks&xwindows.SHIFT_PRESSED != 0 {
+ s.WriteString("shift, ")
+ }
+ if cks&xwindows.CAPSLOCK_ON != 0 {
+ s.WriteString("caps lock, ")
+ }
+ if cks&xwindows.NUMLOCK_ON != 0 {
+ s.WriteString("num lock, ")
+ }
+ if cks&xwindows.SCROLLLOCK_ON != 0 {
+ s.WriteString("scroll lock, ")
+ }
+ if cks&xwindows.ENHANCED_KEY != 0 {
+ s.WriteString("enhanced key, ")
+ }
+ s.WriteString("], repeat count: ")
+ s.WriteString(fmt.Sprintf("%d", repeatCount))
+ return s.String()
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer.go
new file mode 100644
index 000000000..4b55cd25f
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer.go
@@ -0,0 +1,1590 @@
+package uv
+
+import (
+ "bytes"
+ "errors"
+ "hash/maphash"
+ "io"
+ "strings"
+
+ "github.com/charmbracelet/colorprofile"
+ "github.com/charmbracelet/x/ansi"
+)
+
+// ErrInvalidDimensions is returned when the dimensions of a window are invalid
+// for the operation.
+var ErrInvalidDimensions = errors.New("invalid dimensions")
+
+// capabilities represents a mask of supported ANSI escape sequences.
+type capabilities uint
+
+const (
+ // Vertical Position Absolute [ansi.VPA].
+ capVPA capabilities = 1 << iota
+ // Horizontal Position Absolute [ansi.HPA].
+ capHPA
+ // Cursor Horizontal Absolute [ansi.CHA].
+ capCHA
+ // Cursor Horizontal Tab [ansi.CHT].
+ capCHT
+ // Cursor Backward Tab [ansi.CBT].
+ capCBT
+ // Repeat Previous Character [ansi.REP].
+ capREP
+ // Erase Character [ansi.ECH].
+ capECH
+ // Insert Character [ansi.ICH].
+ capICH
+ // Scroll Down [ansi.SD].
+ capSD
+ // Scroll Up [ansi.SU].
+ capSU
+ // These capabilities depend on the tty termios settings and are not
+ // enabled by default.
+ // Tabulation [ansi.HT].
+ capHT
+ // Backspace [ansi.BS].
+ capBS
+
+ noCaps capabilities = 0
+ allCaps = capVPA | capHPA | capCHA | capCHT | capCBT | capREP | capECH | capICH | capSD | capSU
+)
+
+// Set sets the given capabilities.
+func (v *capabilities) Set(c capabilities) {
+ *v |= c
+}
+
+// Reset resets the given capabilities.
+func (v *capabilities) Reset(c capabilities) {
+ *v &^= c
+}
+
+// Contains returns whether the capabilities contains the given capability.
+func (v capabilities) Contains(c capabilities) bool {
+ return v&c == c
+}
+
+// cursor represents a terminal cursor.
+type cursor struct {
+ Cell
+ Position
+}
+
+// LineData represents the metadata for a line.
+type LineData struct {
+ // First and last changed cell indices.
+ FirstCell, LastCell int
+ // Old index used for scrolling
+ oldIndex int //nolint:unused
+}
+
+// tFlag is a bitmask of terminal flags.
+type tFlag uint
+
+// Terminal writer flags.
+const (
+ tRelativeCursor tFlag = 1 << iota
+ tFullscreen
+ tMapNewline
+ tScrollOptim
+)
+
+// Set sets the given flags.
+func (v *tFlag) Set(c tFlag) {
+ *v |= c
+}
+
+// Reset resets the given flags.
+func (v *tFlag) Reset(c tFlag) {
+ *v &^= c
+}
+
+// Contains returns whether the terminal flags contains the given flags.
+func (v tFlag) Contains(c tFlag) bool {
+ return v&c == c
+}
+
+// TerminalRenderer is a terminal screen render and lazy writer that buffers
+// the output until it is flushed. It handles rendering a screen from a
+// [Buffer] to the terminal with the minimal necessary escape sequences to
+// transition the terminal to the new buffer state. It uses various escape
+// sequence optimizations to reduce the number of bytes sent to the terminal.
+// It's designed to be lazy and only flush the output when necessary by calling
+// the [TerminalRenderer.Flush] method.
+//
+// The renderer handles the terminal's alternate screen and cursor visibility
+// via the [TerminalRenderer.EnterAltScreen], [TerminalRenderer.ExitAltScreen],
+// [TerminalRenderer.ShowCursor] and [TerminalRenderer.HideCursor] methods.
+// Using these methods will queue the appropriate escape sequences to enter or
+// exit the alternate screen and show or hide the cursor respectively to be
+// flushed to the terminal.
+//
+// Use the [io.Writer] and [io.StringWriter] interfaces to queue custom
+// commands the renderer.
+//
+// The renderer is not thread-safe, the caller must protect the renderer when
+// using it from multiple goroutines.
+type TerminalRenderer struct {
+ w io.Writer
+ buf *bytes.Buffer // buffer for writing to the screen
+ curbuf *RenderBuffer // the current buffer
+ tabs *TabStops
+ hasher maphash.Hash
+ oldhash, newhash []uint64 // the old and new hash values for each line
+ hashtab []hashmap // the hashmap table
+ oldnum []int // old indices from previous hash
+ cur, saved cursor // the current and saved cursors
+ flags tFlag // terminal writer flags.
+ term string // the terminal type
+ clear bool // whether to force clear the screen
+ caps capabilities // terminal control sequence capabilities
+ atPhantom bool // whether the cursor is out of bounds and at a phantom cell
+ logger Logger // The logger used for debugging.
+
+ // profile is the color profile to use when downsampling colors. This is
+ // used to determine the appropriate color the terminal can display.
+ profile colorprofile.Profile
+}
+
+// NewTerminalRenderer returns a new [TerminalRenderer] that uses the given
+// writer, terminal type, and initializes the width of the terminal. The
+// terminal type is used to determine the capabilities of the terminal and
+// should be set to the value of the TERM environment variable.
+//
+// The renderer will try to detect the color profile from the output and the
+// given environment variables. Use [TerminalRenderer.SetColorProfile] method
+// to set a specific color profile for downsampling.
+//
+// See [TerminalRenderer] for more information on how to use the renderer.
+func NewTerminalRenderer(w io.Writer, env []string) (s *TerminalRenderer) {
+ s = new(TerminalRenderer)
+ s.w = w
+ s.profile = colorprofile.Detect(w, env)
+ s.buf = new(bytes.Buffer)
+ s.term = Environ(env).Getenv("TERM")
+ s.caps = xtermCaps(s.term)
+ s.cur = cursor{Cell: EmptyCell, Position: Pos(-1, -1)} // start at -1 to force a move
+ s.saved = s.cur
+ s.oldhash, s.newhash = nil, nil
+ return
+}
+
+// SetLogger sets the logger to use for debugging. If nil, no logging will be
+// performed.
+func (s *TerminalRenderer) SetLogger(logger Logger) {
+ s.logger = logger
+}
+
+// SetColorProfile sets the color profile to use for downsampling colors. This
+// is used to determine the appropriate color the terminal can display.
+func (s *TerminalRenderer) SetColorProfile(profile colorprofile.Profile) {
+ s.profile = profile
+}
+
+// SetScrollOptim sets whether to use hard scroll optimizations.
+func (s *TerminalRenderer) SetScrollOptim(v bool) {
+ if v {
+ s.flags.Set(tScrollOptim)
+ } else {
+ s.flags.Reset(tScrollOptim)
+ }
+}
+
+// SetMapNewline sets whether the terminal is currently mapping newlines to
+// CRLF or carriage return and line feed. This is used to correctly determine
+// how to move the cursor when writing to the screen.
+func (s *TerminalRenderer) SetMapNewline(v bool) {
+ if v {
+ s.flags.Set(tMapNewline)
+ } else {
+ s.flags.Reset(tMapNewline)
+ }
+}
+
+// SetBackspace sets whether to use backspace as a movement optimization.
+func (s *TerminalRenderer) SetBackspace(v bool) {
+ if v {
+ s.caps.Set(capBS)
+ } else {
+ s.caps.Reset(capBS)
+ }
+}
+
+// SetTabStops sets the tab stops for the terminal and enables hard tabs
+// movement optimizations. Use -1 to disable hard tabs. This option is ignored
+// when the terminal type is "linux" as it does not support hard tabs.
+func (s *TerminalRenderer) SetTabStops(width int) {
+ if width < 0 || strings.HasPrefix(s.term, "linux") {
+ // Linux terminal does not support hard tabs.
+ s.caps.Reset(capHT)
+ } else {
+ s.caps.Set(capHT)
+ s.tabs = DefaultTabStops(width)
+ }
+}
+
+// SetFullscreen sets whether whole screen is being used. This is usually
+// paired with the alternate screen mode, and used to control cursor movements
+// and optimizations when the terminal is occupying the whole screen.
+func (s *TerminalRenderer) SetFullscreen(v bool) {
+ if v {
+ s.flags.Set(tFullscreen)
+ } else {
+ s.flags.Reset(tFullscreen)
+ }
+}
+
+// Fullscreen returns whether whole screen is being used. This is usually
+// paired with the alternate screen mode, and used to control cursor movements
+// and optimizations when the terminal is occupying the whole screen.
+func (s *TerminalRenderer) Fullscreen() bool {
+ return s.flags.Contains(tFullscreen)
+}
+
+// SetRelativeCursor sets whether to use relative cursor movements.
+func (s *TerminalRenderer) SetRelativeCursor(v bool) {
+ if v {
+ s.flags.Set(tRelativeCursor)
+ } else {
+ s.flags.Reset(tRelativeCursor)
+ }
+}
+
+// SaveCursor saves the current cursor position and styles. This can be used
+// when a program enters the alternate screen buffer mode using DECSET 1049
+// [ansi.ModeAltScreenSaveCursor] and wants to restore the cursor position and
+// styles later.
+func (s *TerminalRenderer) SaveCursor() {
+ s.saved = s.cur
+}
+
+// RestoreCursor restores the saved cursor position and styles. This can be
+// used when a program exits the alternate screen buffer mode using DECRST 1049
+// [ansi.ModeAltScreenSaveCursor] and wants to restore the cursor position and
+// styles saved earlier.
+func (s *TerminalRenderer) RestoreCursor() {
+ s.cur = s.saved
+}
+
+// EnterAltScreen is a helper that queues the [ansi.ModeAltScreenSaveCursor]
+// escape sequence to enter the alternate screen buffer and save cursor mode.
+//
+// It saves the current cursor properties, enables
+// [TerminalRenderer.SetFullscreen] flag, and disables
+// [TerminalRenderer.SetRelativeCursor] flag. On the next call to
+// [TerminalRenderer.Render], it will move the cursor home and clear the screen
+// to prepare for rendering the new buffer.
+//
+// Note: you might want to reapply the cursor visibility state after calling
+// this method, as some terminals reset the cursor visibility when switching to
+// the alternate screen.
+func (s *TerminalRenderer) EnterAltScreen() {
+ s.SaveCursor()
+ s.buf.WriteString(ansi.SetModeAltScreenSaveCursor)
+ s.SetFullscreen(true)
+ s.SetRelativeCursor(false)
+ s.Erase()
+}
+
+// ExitAltScreen is a helper that queues the [ansi.ModeAltScreenSaveCursor]
+// escape sequence to exit the alternate screen buffer and restore cursor mode.
+//
+// It restores the saved cursor properties, disables
+// [TerminalRenderer.SetFullscreen] flag, and enables
+// [TerminalRenderer.SetRelativeCursor] flag. On the next call to
+// [TerminalRenderer.Render], it will move the cursor to the first line and
+// clear everything below the cursor to prepare for rendering the new buffer.
+//
+// Note: you might want to reapply the cursor visibility state after calling
+// this method, as some terminals reset the cursor visibility when switching to
+// the alternate screen.
+func (s *TerminalRenderer) ExitAltScreen() {
+ s.Erase()
+ s.SetRelativeCursor(true)
+ s.SetFullscreen(false)
+ s.buf.WriteString(ansi.ResetModeAltScreenSaveCursor)
+ s.RestoreCursor()
+}
+
+// PrependString adds the lines of the given string to the top of the terminal
+// screen. The lines prepended are not managed by the renderer and will not be
+// cleared or updated by the renderer.
+//
+// Using this when the terminal is using the alternate screen or when occupying
+// the whole screen may not produce any visible effects. This is because
+// once the terminal writes the prepended lines, they will get overwritten
+// by the next frame.
+func (s *TerminalRenderer) PrependString(newbuf *RenderBuffer, str string) {
+ if len(str) == 0 {
+ return
+ }
+
+ // TODO: Use scrolling region if available.
+ // TODO: Use [Screen.Write] [io.Writer] interface.
+
+ // We need to scroll the screen up by the number of lines in the queue.
+ // We can't use [ansi.SU] because we want the cursor to move down until
+ // it reaches the bottom of the screen.
+ w, h := newbuf.Width(), newbuf.Height()
+ s.move(newbuf, 0, h-1)
+ lines := strings.Split(str, "\n")
+ offset := 0
+ for _, line := range lines {
+ lineWidth := ansi.StringWidth(line)
+ if w > 0 && lineWidth > w {
+ offset += (lineWidth / w)
+ }
+ if lineWidth == 0 || lineWidth%w != 0 {
+ offset++
+ }
+ }
+
+ s.buf.WriteString(strings.Repeat("\n", offset))
+ s.cur.Y += offset
+ // XXX: Now go to the top of the screen, insert new lines, and write
+ // the queued strings. It is important to use [Screen.moveCursor]
+ // instead of [Screen.move] because we don't want to perform any checks
+ // on the cursor position.
+ s.moveCursor(newbuf, 0, 0, false)
+ s.buf.WriteString(ansi.InsertLine(offset))
+ for _, line := range lines {
+ s.buf.WriteString(line)
+ s.buf.WriteString("\r\n")
+ }
+}
+
+// moveCursor moves the cursor to the specified position.
+//
+// It is safe to call this function with a nil [Buffer], in that case, it won't
+// be using any optimizations that depend on the buffer.
+func (s *TerminalRenderer) moveCursor(newbuf *RenderBuffer, x, y int, overwrite bool) {
+ if !s.flags.Contains(tFullscreen) && s.flags.Contains(tRelativeCursor) &&
+ s.cur.X == -1 && s.cur.Y == -1 {
+ // First cursor movement in inline mode, move the cursor to the first
+ // column before moving to the target position.
+ _ = s.buf.WriteByte('\r')
+ s.cur.X, s.cur.Y = 0, 0
+ }
+ seq := moveCursor(s, newbuf, x, y, overwrite)
+ _, _ = s.buf.WriteString(seq)
+ s.cur.X, s.cur.Y = x, y
+}
+
+// move moves the cursor to the specified position in the buffer.
+//
+// It is safe to call this function with a nil [Buffer], in that case, it won't
+// be using any optimizations that depend on the buffer.
+func (s *TerminalRenderer) move(newbuf *RenderBuffer, x, y int) {
+ // XXX: Make sure we use the max height and width of the buffer in case
+ // we're in the middle of a resize operation.
+ var width, height int
+ if s.curbuf != nil {
+ width, height = s.curbuf.Width(), s.curbuf.Height()
+ }
+ if newbuf != nil {
+ width = max(newbuf.Width(), width)
+ height = max(newbuf.Height(), height)
+ }
+
+ if width > 0 && x >= width {
+ // Handle autowrap
+ y += (x / width)
+ x %= width
+ }
+
+ // XXX: Disable styles if there's any
+ // Some move operations such as [ansi.LF] can apply styles to the new
+ // cursor position, thus, we need to reset the styles before moving the
+ // cursor.
+ blank := s.clearBlank()
+ resetPen := y != s.cur.Y && !blank.Equal(&EmptyCell)
+ if resetPen {
+ s.updatePen(nil)
+ }
+
+ // Reset wrap around (phantom cursor) state
+ if s.atPhantom {
+ s.cur.X = 0
+ _ = s.buf.WriteByte('\r')
+ s.atPhantom = false // reset phantom cell state
+ }
+
+ // TODO: Investigate if we need to handle this case and/or if we need the
+ // following code.
+ //
+ // if width > 0 && s.cur.X >= width {
+ // l := (s.cur.X + 1) / width
+ //
+ // s.cur.Y += l
+ // if height > 0 && s.cur.Y >= height {
+ // l -= s.cur.Y - height - 1
+ // }
+ //
+ // if l > 0 {
+ // s.cur.X = 0
+ // s.buf.WriteString("\r" + strings.Repeat("\n", l)) //nolint:errcheck
+ // }
+ // }
+
+ if height > 0 {
+ if s.cur.Y > height-1 {
+ s.cur.Y = height - 1
+ }
+ if y > height-1 {
+ y = height - 1
+ }
+ }
+
+ if x == s.cur.X && y == s.cur.Y {
+ // We give up later because we need to run checks for the phantom cell
+ // and others before we can determine if we can give up.
+ return
+ }
+
+ // We set the new cursor in tscreen.moveCursor].
+ s.moveCursor(newbuf, x, y, true) // Overwrite cells if possible
+}
+
+// cellEqual returns whether the two cells are equal. A nil cell is considered
+// a [EmptyCell].
+func cellEqual(a, b *Cell) bool {
+ if a == b {
+ return true
+ }
+ // TODO: This is needed to handle empty lines correctly when scroll
+ // optimizations are enabled. Instead, a nil check should be equivalent to
+ // checking for an [EmptyCell], should it?
+ // Investigate why when we assign the pointers to &[EmptyCell], this causes
+ // scroll optimization related artifacts where excess lines are left behind
+ // in empty lines after scrolling.
+ if a == nil || b == nil {
+ return false
+ }
+ return a.Equal(b)
+}
+
+// putCell draws a cell at the current cursor position.
+func (s *TerminalRenderer) putCell(newbuf *RenderBuffer, cell *Cell) {
+ width, height := newbuf.Width(), newbuf.Height()
+ if s.flags.Contains(tFullscreen) && s.cur.X == width-1 && s.cur.Y == height-1 {
+ s.putCellLR(newbuf, cell)
+ } else {
+ s.putAttrCell(newbuf, cell)
+ }
+}
+
+// wrapCursor wraps the cursor to the next line.
+func (s *TerminalRenderer) wrapCursor() {
+ const autoRightMargin = true
+ if autoRightMargin {
+ // Assume we have auto wrap mode enabled.
+ s.cur.X = 0
+ s.cur.Y++
+ } else {
+ s.cur.X--
+ }
+}
+
+func (s *TerminalRenderer) putAttrCell(newbuf *RenderBuffer, cell *Cell) {
+ if cell != nil && cell.IsZero() {
+ // XXX: Zero width cells are special and should not be written to the
+ // screen no matter what other attributes they have.
+ // Zero width cells are used for wide characters that are split into
+ // multiple cells.
+ return
+ }
+
+ // We're at pending wrap state (phantom cell), incoming cell should
+ // wrap.
+ if s.atPhantom {
+ s.wrapCursor()
+ s.atPhantom = false
+ }
+
+ s.updatePen(cell)
+ cellWidth := 1
+ if cell == nil {
+ _ = s.buf.WriteByte(' ')
+ } else {
+ _, _ = s.buf.WriteString(cell.Content)
+ cellWidth = cell.Width
+ }
+
+ s.cur.X += cellWidth
+ if s.cur.X >= newbuf.Width() {
+ s.atPhantom = true
+ }
+}
+
+// putCellLR draws a cell at the lower right corner of the screen.
+func (s *TerminalRenderer) putCellLR(newbuf *RenderBuffer, cell *Cell) {
+ // Optimize for the lower right corner cell.
+ curX := s.cur.X
+ if cell == nil || !cell.IsZero() {
+ _, _ = s.buf.WriteString(ansi.ResetModeAutoWrap)
+ s.putAttrCell(newbuf, cell)
+ // Writing to lower-right corner cell should not wrap.
+ s.atPhantom = false
+ s.cur.X = curX
+ _, _ = s.buf.WriteString(ansi.SetModeAutoWrap)
+ }
+}
+
+// updatePen updates the cursor pen styles.
+func (s *TerminalRenderer) updatePen(cell *Cell) {
+ if cell == nil {
+ if !s.cur.Style.IsZero() {
+ _, _ = s.buf.WriteString(ansi.ResetStyle)
+ s.cur.Style = Style{} // Reset style
+ }
+ if !s.cur.Link.IsZero() {
+ _, _ = s.buf.WriteString(ansi.ResetHyperlink())
+ }
+ return
+ }
+
+ // Downsample pen when we don't have a [colorprofile.TrueColor],
+ // otherwise, use the original style.
+ newStyle := ConvertStyle(cell.Style, s.profile)
+ newLink := ConvertLink(cell.Link, s.profile)
+ oldStyle := ConvertStyle(s.cur.Style, s.profile)
+ oldLink := ConvertLink(s.cur.Link, s.profile)
+
+ if !newStyle.Equal(&oldStyle) {
+ seq := newStyle.Diff(&oldStyle)
+ if newStyle.IsZero() && len(seq) > len(ansi.ResetStyle) {
+ seq = ansi.ResetStyle
+ }
+ _, _ = s.buf.WriteString(seq)
+ s.cur.Style = cell.Style // Copy the original style
+ }
+ if !newLink.Equal(&oldLink) {
+ _, _ = s.buf.WriteString(ansi.SetHyperlink(newLink.URL, newLink.Params))
+ s.cur.Link = cell.Link // Copy the original link
+ }
+}
+
+// canClearWith checks whether the given cell can be used by clearing commands
+// like [ansi.EL] to clear the screen. It tests if a cell is empty i.e. space
+// or blank and doesn't include any bad style attributes such as [AttrReverse].
+func canClearWith(c *Cell) bool {
+ if c == nil {
+ return true
+ }
+ if c.Width != 1 || len(c.Content) != 1 || c.Content != " " {
+ return false
+ }
+ // NOTE: This assumes that the terminal supports bce terminfo capability
+ // which all xterm-compatible terminals and terminals that use xterm*
+ // terminal types do.
+ return c.Style.Underline == UnderlineNone &&
+ c.Style.Attrs&^(AttrBold|AttrFaint|AttrItalic|AttrBlink|AttrRapidBlink) == 0 &&
+ c.Link.IsZero()
+}
+
+// emitRange emits a range of cells to the buffer. It it equivalent to calling
+// tscreen.putCell] for each cell in the range. This is optimized to use
+// [ansi.ECH] and [ansi.REP].
+// Returns whether the cursor is at the end of interval or somewhere in the
+// middle.
+func (s *TerminalRenderer) emitRange(newbuf *RenderBuffer, line Line, n int) (eoi bool) {
+ hasECH := s.caps.Contains(capECH)
+ hasREP := s.caps.Contains(capREP)
+ if hasECH || hasREP { //nolint:nestif
+ for n > 0 {
+ var count int
+ for n > 1 && !cellEqual(line.At(0), line.At(1)) {
+ s.putCell(newbuf, line.At(0))
+ line = line[1:]
+ n--
+ }
+
+ cell0 := line[0]
+ if n == 1 {
+ s.putCell(newbuf, &cell0)
+ return false
+ }
+
+ count = 2
+ for count < n && cellEqual(line.At(count), &cell0) {
+ count++
+ }
+
+ ech := ansi.EraseCharacter(count)
+ cup := ansi.CursorPosition(s.cur.X+count, s.cur.Y)
+ rep := ansi.RepeatPreviousCharacter(count)
+ if hasECH && count > len(ech)+len(cup) && canClearWith(&cell0) {
+ s.updatePen(&cell0)
+ _, _ = s.buf.WriteString(ech)
+
+ // If this is the last cell, we don't need to move the cursor.
+ if count < n {
+ s.move(newbuf, s.cur.X+count, s.cur.Y)
+ } else {
+ return true // cursor in the middle
+ }
+ } else if hasREP && count > len(rep) &&
+ (len(cell0.Content) == 1 && cell0.Content[0] >= ansi.US && cell0.Content[0] < ansi.DEL) {
+ // We only support ASCII characters. Most terminals will handle
+ // non-ASCII characters correctly, but some might not, ahem xterm.
+ //
+ // NOTE: [ansi.REP] only repeats the last rune and won't work
+ // if the last cell contains multiple runes.
+
+ wrapPossible := s.cur.X+count >= newbuf.Width()
+ repCount := count
+ if wrapPossible {
+ repCount--
+ }
+
+ s.updatePen(&cell0)
+ s.putCell(newbuf, &cell0)
+ repCount-- // cell0 is a single width cell ASCII character
+
+ _, _ = s.buf.WriteString(ansi.RepeatPreviousCharacter(repCount))
+ s.cur.X += repCount
+ if wrapPossible {
+ s.putCell(newbuf, &cell0)
+ }
+ } else {
+ for i := 0; i < count; i++ {
+ s.putCell(newbuf, line.At(i))
+ }
+ }
+
+ line = line[clamp(count, 0, len(line)):]
+ n -= count
+ }
+
+ return false
+ }
+
+ for i := 0; i < n; i++ {
+ s.putCell(newbuf, line.At(i))
+ }
+
+ return false
+}
+
+// putRange puts a range of cells from the old line to the new line.
+// Returns whether the cursor is at the end of interval or somewhere in the
+// middle.
+func (s *TerminalRenderer) putRange(newbuf *RenderBuffer, oldLine, newLine Line, y, start, end int) (eoi bool) {
+ inline := min(len(ansi.CursorPosition(start+1, y+1)),
+ min(len(ansi.HorizontalPositionAbsolute(start+1)),
+ len(ansi.CursorForward(start+1))))
+ if (end - start + 1) > inline { //nolint:nestif
+ var j, same int
+ for j, same = start, 0; j <= end; j++ {
+ oldCell, newCell := oldLine.At(j), newLine.At(j)
+ if same == 0 && oldCell != nil && oldCell.IsZero() {
+ continue
+ }
+ if cellEqual(oldCell, newCell) {
+ same++
+ } else {
+ if same > end-start {
+ s.emitRange(newbuf, newLine[start:], j-same-start)
+ s.move(newbuf, j, y)
+ start = j
+ }
+ same = 0
+ }
+ }
+
+ i := s.emitRange(newbuf, newLine[start:], j-same-start)
+
+ // Always return 1 for the next [tScreen.move] after a
+ // [tScreen.putRange] if we found identical characters at end of
+ // interval.
+ if same == 0 {
+ return i
+ }
+ return true
+ }
+
+ return s.emitRange(newbuf, newLine[start:], end-start+1)
+}
+
+// clearToEnd clears the screen from the current cursor position to the end of
+// line.
+func (s *TerminalRenderer) clearToEnd(newbuf *RenderBuffer, blank *Cell, force bool) {
+ if s.cur.Y >= 0 {
+ curline := s.curbuf.Line(s.cur.Y)
+ // We use the newbuf width because the current buffer might be smaller
+ // than the new buffer during a resize operation and we want to detect
+ // that.
+ for j := s.cur.X; j < newbuf.Width(); j++ {
+ if j >= 0 {
+ c := curline.At(j)
+ if !cellEqual(c, blank) {
+ curline.Set(j, blank)
+ force = true
+ }
+ }
+ }
+ }
+
+ if force {
+ s.updatePen(blank)
+ count := newbuf.Width() - s.cur.X
+ if s.el0Cost() <= count {
+ _, _ = s.buf.WriteString(ansi.EraseLineRight)
+ } else {
+ for i := 0; i < count; i++ {
+ s.putCell(newbuf, blank)
+ }
+ }
+ }
+}
+
+// clearBlank returns a blank cell based on the current cursor background color.
+func (s *TerminalRenderer) clearBlank() *Cell {
+ return &s.cur.Cell
+}
+
+// insertCells inserts the count cells pointed by the given line at the current
+// cursor position.
+func (s *TerminalRenderer) insertCells(newbuf *RenderBuffer, line Line, count int) {
+ supportsICH := s.caps.Contains(capICH)
+ if supportsICH {
+ // Use [ansi.ICH] as an optimization.
+ _, _ = s.buf.WriteString(ansi.InsertCharacter(count))
+ } else {
+ // Otherwise, use [ansi.IRM] mode.
+ _, _ = s.buf.WriteString(ansi.SetModeInsertReplace)
+ }
+
+ for i := 0; count > 0; i++ {
+ s.putAttrCell(newbuf, line.At(i))
+ count--
+ }
+
+ if !supportsICH {
+ _, _ = s.buf.WriteString(ansi.ResetModeInsertReplace)
+ }
+}
+
+// el0Cost returns the cost of using [ansi.EL] 0 i.e. [ansi.EraseLineRight]. If
+// this terminal supports background color erase, it can be cheaper to use
+// [ansi.EL] 0 i.e. [ansi.EraseLineRight] to clear
+// trailing spaces.
+func (s *TerminalRenderer) el0Cost() int {
+ if s.caps != noCaps {
+ return 0
+ }
+ return len(ansi.EraseLineRight)
+}
+
+// transformLine transforms the given line in the current window to the
+// corresponding line in the new window. It uses [ansi.ICH] and [ansi.DCH] to
+// insert or delete characters.
+func (s *TerminalRenderer) transformLine(newbuf *RenderBuffer, y int) {
+ var firstCell, oLastCell, nLastCell int // first, old last, new last index
+ oldLine := s.curbuf.Line(y)
+ newLine := newbuf.Line(y)
+
+ // Find the first changed cell in the line
+ blank := newLine.At(0)
+
+ // It might be cheaper to clear leading spaces with [ansi.EL] 1 i.e.
+ // [ansi.EraseLineLeft].
+ if canClearWith(blank) { //nolint:nestif
+ var oFirstCell, nFirstCell int
+ for oFirstCell = 0; oFirstCell < s.curbuf.Width(); oFirstCell++ {
+ if !cellEqual(oldLine.At(oFirstCell), blank) {
+ break
+ }
+ }
+ for nFirstCell = 0; nFirstCell < newbuf.Width(); nFirstCell++ {
+ if !cellEqual(newLine.At(nFirstCell), blank) {
+ break
+ }
+ }
+
+ if nFirstCell == oFirstCell {
+ firstCell = nFirstCell
+
+ // Find the first differing cell
+ for firstCell < newbuf.Width() &&
+ cellEqual(oldLine.At(firstCell), newLine.At(firstCell)) {
+ firstCell++
+ }
+ } else if oFirstCell > nFirstCell {
+ firstCell = nFirstCell
+ } else if oFirstCell < nFirstCell {
+ firstCell = oFirstCell
+ el1Cost := len(ansi.EraseLineLeft)
+ if el1Cost < nFirstCell-oFirstCell {
+ if nFirstCell >= newbuf.Width() {
+ s.move(newbuf, 0, y)
+ s.updatePen(blank)
+ _, _ = s.buf.WriteString(ansi.EraseLineRight)
+ } else {
+ s.move(newbuf, nFirstCell-1, y)
+ s.updatePen(blank)
+ _, _ = s.buf.WriteString(ansi.EraseLineLeft)
+ }
+
+ for firstCell < nFirstCell {
+ oldLine.Set(firstCell, blank)
+ firstCell++
+ }
+ }
+ }
+ } else {
+ // Find the first differing cell
+ for firstCell < newbuf.Width() && cellEqual(newLine.At(firstCell), oldLine.At(firstCell)) {
+ firstCell++
+ }
+ }
+
+ // If we didn't find one, we're done
+ if firstCell >= newbuf.Width() {
+ return
+ }
+
+ blank = newLine.At(newbuf.Width() - 1)
+ if blank != nil && !canClearWith(blank) {
+ // Find the last differing cell
+ nLastCell = newbuf.Width() - 1
+ for nLastCell > firstCell && cellEqual(newLine.At(nLastCell), oldLine.At(nLastCell)) {
+ nLastCell--
+ }
+
+ if nLastCell >= firstCell {
+ s.move(newbuf, firstCell, y)
+ s.putRange(newbuf, oldLine, newLine, y, firstCell, nLastCell)
+ if firstCell < len(oldLine) && firstCell < len(newLine) {
+ copy(oldLine[firstCell:], newLine[firstCell:])
+ } else {
+ copy(oldLine, newLine)
+ }
+ }
+
+ return
+ }
+
+ // Find last non-blank cell in the old line.
+ // We always use the newbuf width to detect new cell changes.
+ oLastCell = newbuf.Width() - 1
+ for oLastCell > firstCell && cellEqual(oldLine.At(oLastCell), blank) {
+ oLastCell--
+ }
+
+ // Find last non-blank cell in the new line.
+ // We always use the newbuf width to detect new cell changes.
+ nLastCell = newbuf.Width() - 1
+ for nLastCell > firstCell && cellEqual(newLine.At(nLastCell), blank) {
+ nLastCell--
+ }
+
+ if nLastCell == firstCell && s.el0Cost() < oLastCell-nLastCell { //nolint:nestif
+ s.move(newbuf, firstCell, y)
+ if !cellEqual(newLine.At(firstCell), blank) {
+ s.putCell(newbuf, newLine.At(firstCell))
+ }
+ s.clearToEnd(newbuf, blank, false)
+ } else if nLastCell != oLastCell &&
+ !cellEqual(newLine.At(nLastCell), oldLine.At(oLastCell)) {
+ s.move(newbuf, firstCell, y)
+ if oLastCell-nLastCell > s.el0Cost() {
+ if s.putRange(newbuf, oldLine, newLine, y, firstCell, nLastCell) {
+ s.move(newbuf, nLastCell+1, y)
+ }
+ s.clearToEnd(newbuf, blank, false)
+ } else {
+ n := max(nLastCell, oLastCell)
+ s.putRange(newbuf, oldLine, newLine, y, firstCell, n)
+ }
+ } else {
+ nLastNonBlank := nLastCell
+ oLastNonBlank := oLastCell
+
+ // Find the last cells that really differ.
+ // Can be -1 if no cells differ.
+ for cellEqual(newLine.At(nLastCell), oldLine.At(oLastCell)) {
+ if !cellEqual(newLine.At(nLastCell-1), oldLine.At(oLastCell-1)) {
+ break
+ }
+ nLastCell--
+ oLastCell--
+ if nLastCell == -1 || oLastCell == -1 {
+ break
+ }
+ }
+
+ n := min(oLastCell, nLastCell)
+ if n >= firstCell {
+ s.move(newbuf, firstCell, y)
+ s.putRange(newbuf, oldLine, newLine, y, firstCell, n)
+ }
+
+ if oLastCell < nLastCell {
+ m := max(nLastNonBlank, oLastNonBlank)
+ if n != 0 {
+ for n > 0 {
+ wide := newLine.At(n + 1)
+ if wide == nil || !wide.IsZero() {
+ break
+ }
+ n--
+ oLastCell--
+ }
+ } else if n >= firstCell && newLine.At(n) != nil && newLine.At(n).Width > 1 {
+ next := newLine.At(n + 1)
+ for next != nil && next.IsZero() {
+ n++
+ oLastCell++
+ }
+ }
+
+ // TODO: This can sometimes send unnecessary cursor movements with
+ // negative or zero ranges. This could happen on a screen resize
+ // where oLastCell < nLastCell and oLastCell is -1 or less.
+ // Investigate and fix.
+ s.move(newbuf, n+1, y)
+ ichCost := 3 + nLastCell - oLastCell
+ if s.caps.Contains(capICH) && (nLastCell < nLastNonBlank || ichCost > (m-n)) {
+ s.putRange(newbuf, oldLine, newLine, y, n+1, m)
+ } else {
+ s.insertCells(newbuf, newLine[n+1:], nLastCell-oLastCell)
+ }
+ } else if oLastCell > nLastCell {
+ s.move(newbuf, n+1, y)
+ dchCost := 3 + oLastCell - nLastCell
+ if dchCost > len(ansi.EraseLineRight)+nLastNonBlank-(n+1) {
+ if s.putRange(newbuf, oldLine, newLine, y, n+1, nLastNonBlank) {
+ s.move(newbuf, nLastNonBlank+1, y)
+ }
+ s.clearToEnd(newbuf, blank, false)
+ } else {
+ s.updatePen(blank)
+ s.deleteCells(oLastCell - nLastCell)
+ }
+ }
+ }
+
+ // Update the old line with the new line
+ if firstCell < len(oldLine) && firstCell < len(newLine) {
+ copy(oldLine[firstCell:], newLine[firstCell:])
+ } else {
+ copy(oldLine, newLine)
+ }
+}
+
+// deleteCells deletes the count cells at the current cursor position and moves
+// the rest of the line to the left. This is equivalent to [ansi.DCH].
+func (s *TerminalRenderer) deleteCells(count int) {
+ // [ansi.DCH] will shift in cells from the right margin so we need to
+ // ensure that they are the right style.
+ _, _ = s.buf.WriteString(ansi.DeleteCharacter(count))
+}
+
+// clearToBottom clears the screen from the current cursor position to the end
+// of the screen.
+func (s *TerminalRenderer) clearToBottom(blank *Cell) {
+ row, col := s.cur.Y, s.cur.X
+ if row < 0 {
+ row = 0
+ }
+
+ s.updatePen(blank)
+ _, _ = s.buf.WriteString(ansi.EraseScreenBelow)
+ // Clear the rest of the current line
+ s.curbuf.ClearArea(Rect(col, row, s.curbuf.Width()-col, 1))
+ // Clear everything below the current line
+ s.curbuf.ClearArea(Rect(0, row+1, s.curbuf.Width(), s.curbuf.Height()-row-1))
+}
+
+// clearBottom tests if clearing the end of the screen would satisfy part of
+// the screen update. Scan backwards through lines in the screen checking if
+// each is blank and one or more are changed.
+// It returns the top line.
+func (s *TerminalRenderer) clearBottom(newbuf *RenderBuffer, total int) (top int) {
+ if total <= 0 {
+ return 0
+ }
+
+ top = total
+ last := min(s.curbuf.Width(), newbuf.Width())
+ blank := s.clearBlank()
+ canClearWithBlank := canClearWith(blank)
+
+ if canClearWithBlank { //nolint:nestif
+ var row int
+ for row = total - 1; row >= 0; row-- {
+ oldLine := s.curbuf.Line(row)
+ newLine := newbuf.Line(row)
+
+ var col int
+ ok := true
+ for col = 0; ok && col < last; col++ {
+ ok = cellEqual(newLine.At(col), blank)
+ }
+ if !ok {
+ break
+ }
+
+ for col = 0; ok && col < last; col++ {
+ ok = cellEqual(oldLine.At(col), blank)
+ }
+ if !ok {
+ top = row
+ }
+ }
+
+ if top < total {
+ s.move(newbuf, 0, max(0, top-1)) // top is 1-based
+ s.clearToBottom(blank)
+ if s.oldhash != nil && s.newhash != nil &&
+ row < len(s.oldhash) && row < len(s.newhash) {
+ for row := top; row < newbuf.Height(); row++ {
+ s.oldhash[row] = s.newhash[row]
+ }
+ }
+ }
+ }
+
+ return top
+}
+
+// clearScreen clears the screen and put cursor at home.
+func (s *TerminalRenderer) clearScreen(blank *Cell) {
+ s.updatePen(blank)
+ _, _ = s.buf.WriteString(ansi.CursorHomePosition)
+ _, _ = s.buf.WriteString(ansi.EraseEntireScreen)
+ s.cur.X, s.cur.Y = 0, 0
+ s.curbuf.Fill(blank)
+}
+
+// clearBelow clears everything below and including the row.
+func (s *TerminalRenderer) clearBelow(newbuf *RenderBuffer, blank *Cell, row int) {
+ s.move(newbuf, 0, row)
+ s.clearToBottom(blank)
+}
+
+// clearUpdate forces a screen redraw.
+func (s *TerminalRenderer) clearUpdate(newbuf *RenderBuffer) {
+ blank := s.clearBlank()
+ var nonEmpty int
+ if s.flags.Contains(tFullscreen) {
+ // XXX: We're using the maximum height of the two buffers to ensure we
+ // write newly added lines to the screen in
+ // [terminalWriter.transformLine].
+ nonEmpty = max(s.curbuf.Height(), newbuf.Height())
+ s.clearScreen(blank)
+ } else {
+ nonEmpty = newbuf.Height()
+ // FIXME: Investigate the double [ansi.ClearScreenBelow] call.
+ // Commenting the line below out seems to work but it might cause other
+ // bugs.
+ s.clearBelow(newbuf, blank, 0)
+ }
+ nonEmpty = s.clearBottom(newbuf, nonEmpty)
+ for i := 0; i < nonEmpty && i < newbuf.Height(); i++ {
+ s.transformLine(newbuf, i)
+ }
+}
+
+func (s *TerminalRenderer) logf(format string, args ...any) {
+ if s.logger == nil {
+ return
+ }
+ s.logger.Printf(format, args...)
+}
+
+// Buffered returns the number of bytes buffered for the next flush.
+func (s *TerminalRenderer) Buffered() int {
+ return s.buf.Len()
+}
+
+// Flush flushes the buffer to the screen.
+func (s *TerminalRenderer) Flush() (err error) {
+ // Write the buffer
+ if n := s.buf.Len(); n > 0 {
+ bts := s.buf.Bytes()
+ if s.logger != nil {
+ s.logf("output: %q", bts)
+ }
+ _, err = s.w.Write(bts)
+ s.buf.Reset()
+ }
+ return
+}
+
+// Redraw forces a full redraw of the screen. It's equivalent to calling
+// [TerminalRenderer.Erase] and [TerminalRenderer.Render].
+func (s *TerminalRenderer) Redraw(newbuf *RenderBuffer) {
+ s.clear = true
+ s.Render(newbuf)
+}
+
+// Render renders changes of the screen to the internal buffer. Call
+// [terminalWriter.Flush] to flush pending changes to the screen.
+func (s *TerminalRenderer) Render(newbuf *RenderBuffer) {
+ // Do we need to render anything?
+ touchedLines := newbuf.TouchedLines()
+ if !s.clear && touchedLines == 0 {
+ return
+ }
+
+ if s.curbuf == nil || s.curbuf.Bounds().Empty() {
+ // Initialize the current buffer
+ s.curbuf = NewRenderBuffer(newbuf.Width(), newbuf.Height())
+ }
+
+ newWidth, newHeight := newbuf.Width(), newbuf.Height()
+ curWidth, curHeight := s.curbuf.Width(), s.curbuf.Height()
+
+ if curWidth != newWidth || curHeight != newHeight {
+ s.oldhash, s.newhash = nil, nil
+ }
+
+ // TODO: Investigate whether this is necessary. Theoretically, terminals
+ // can add/remove tab stops and we should be able to handle that. We could
+ // use [ansi.DECTABSR] to read the tab stops, but that's not implemented in
+ // most terminals :/
+ // // Are we using hard tabs? If so, ensure tabs are using the
+ // // default interval using [ansi.DECST8C].
+ // if s.opts.HardTabs && !s.initTabs {
+ // s.buf.WriteString(ansi.SetTabEvery8Columns)
+ // s.initTabs = true
+ // }
+
+ var nonEmpty int
+
+ // XXX: In inline mode, after a screen resize, we need to clear the extra
+ // lines at the bottom of the screen. This is because in inline mode, we
+ // don't use the full screen height and the current buffer size might be
+ // larger than the new buffer size.
+ partialClear := !s.flags.Contains(tFullscreen) && s.cur.X != -1 && s.cur.Y != -1 &&
+ curWidth == newWidth &&
+ curHeight > 0 &&
+ curHeight > newHeight
+
+ if !s.clear && partialClear {
+ s.clearBelow(newbuf, nil, newHeight-1)
+ }
+
+ if s.clear { //nolint:nestif
+ s.clearUpdate(newbuf)
+ s.clear = false
+ } else if touchedLines > 0 {
+ // On Windows, there's a bug with Windows Terminal where [ansi.DECSTBM]
+ // misbehaves and moves the cursor outside of the scrolling region. For
+ // now, we disable the optimizations completely on Windows.
+ // See https://github.com/microsoft/terminal/issues/19016
+ if s.flags.Contains(tScrollOptim) && s.flags.Contains(tFullscreen) {
+ // Optimize scrolling for the alternate screen buffer.
+ // TODO: Should we optimize for inline mode as well? If so, we need
+ // to know the actual cursor position to use [ansi.DECSTBM].
+ s.scrollOptimize(newbuf)
+ }
+
+ var changedLines int
+ var i int
+
+ if s.flags.Contains(tFullscreen) {
+ nonEmpty = min(curHeight, newHeight)
+ } else {
+ nonEmpty = newHeight
+ }
+
+ nonEmpty = s.clearBottom(newbuf, nonEmpty)
+ for i = 0; i < nonEmpty && i < newHeight; i++ {
+ if newbuf.Touched == nil || i >= len(newbuf.Touched) || (newbuf.Touched[i] != nil &&
+ (newbuf.Touched[i].FirstCell != -1 || newbuf.Touched[i].LastCell != -1)) {
+ s.transformLine(newbuf, i)
+ changedLines++
+ }
+
+ // Mark line changed successfully.
+ if i < len(newbuf.Touched) && i <= newbuf.Height()-1 {
+ newbuf.Touched[i] = &LineData{
+ FirstCell: -1, LastCell: -1,
+ }
+ }
+ if i < len(s.curbuf.Touched) && i < s.curbuf.Height()-1 {
+ s.curbuf.Touched[i] = &LineData{
+ FirstCell: -1, LastCell: -1,
+ }
+ }
+ }
+ }
+
+ if !s.flags.Contains(tFullscreen) && (curWidth != newWidth || curHeight != newHeight) {
+ s.move(newbuf, 0, newHeight-1)
+ }
+
+ // Sync windows and screen
+ newbuf.Touched = make([]*LineData, newHeight)
+ for i := range newbuf.Touched {
+ newbuf.Touched[i] = &LineData{
+ FirstCell: -1, LastCell: -1,
+ }
+ }
+ for i := range s.curbuf.Touched {
+ s.curbuf.Touched[i] = &LineData{
+ FirstCell: -1, LastCell: -1,
+ }
+ }
+
+ if curWidth != newWidth || curHeight != newHeight {
+ // Resize the old buffer to match the new buffer.
+ s.curbuf.Resize(newWidth, newHeight)
+ // Sync new lines to old lines
+ for i := curHeight - 1; i < newHeight; i++ {
+ copy(s.curbuf.Line(i), newbuf.Line(i))
+ }
+ }
+
+ s.updatePen(nil) // nil indicates a blank cell with no styles
+}
+
+// Erase marks the screen to be fully erased on the next render.
+func (s *TerminalRenderer) Erase() {
+ s.clear = true
+}
+
+// Resize updates the terminal screen tab stops. This is used to calculate
+// terminal tab stops for hard tab optimizations.
+func (s *TerminalRenderer) Resize(width, _ int) {
+ if s.tabs != nil {
+ s.tabs.Resize(width)
+ }
+}
+
+// Position returns the cursor position in the screen buffer after applying any
+// pending transformations from the underlying buffer.
+func (s *TerminalRenderer) Position() (x, y int) {
+ return s.cur.X, s.cur.Y
+}
+
+// SetPosition changes the logical cursor position. This can be used when we
+// change the cursor position outside of the screen and need to update the
+// screen cursor position.
+// This changes the cursor position for both normal and alternate screen
+// buffers.
+func (s *TerminalRenderer) SetPosition(x, y int) {
+ s.cur.X, s.cur.Y = x, y
+}
+
+// WriteString writes the given string to the underlying buffer.
+func (s *TerminalRenderer) WriteString(str string) (int, error) {
+ return s.buf.WriteString(str) //nolint:wrapcheck
+}
+
+// Write writes the given bytes to the underlying buffer.
+func (s *TerminalRenderer) Write(b []byte) (int, error) {
+ return s.buf.Write(b) //nolint:wrapcheck
+}
+
+// MoveTo calculates and writes the shortest sequence to move the cursor to the
+// given position. It uses the current cursor position and the new position to
+// calculate the shortest amount of sequences to move the cursor.
+func (s *TerminalRenderer) MoveTo(x, y int) {
+ s.move(nil, x, y)
+}
+
+// notLocal returns whether the coordinates are not considered local movement
+// using the defined thresholds.
+// This takes the number of columns, and the coordinates of the current and
+// target positions.
+func notLocal(cols, fx, fy, tx, ty int) bool {
+ // The typical distance for a [ansi.CUP] sequence. Anything less than this
+ // is considered local movement.
+ const longDist = 8 - 1
+ return (tx > longDist) &&
+ (tx < cols-1-longDist) &&
+ (abs(ty-fy)+abs(tx-fx) > longDist)
+}
+
+// relativeCursorMove returns the relative cursor movement sequence using one or two
+// of the following sequences [ansi.CUU], [ansi.CUD], [ansi.CUF], [ansi.CUB],
+// [ansi.VPA], [ansi.HPA].
+// When overwrite is true, this will try to optimize the sequence by using the
+// screen cells values to move the cursor instead of using escape sequences.
+//
+// It is safe to call this function with a nil [Buffer]. In that case, it won't
+// use any optimizations that require the new buffer such as overwrite.
+func relativeCursorMove(s *TerminalRenderer, newbuf *RenderBuffer, fx, fy, tx, ty int, overwrite, useTabs, useBackspace bool) string {
+ var seq strings.Builder
+ if newbuf == nil {
+ overwrite = false // We can't overwrite the current buffer.
+ }
+
+ if ty != fy { //nolint:nestif
+ var yseq string
+ if s.caps.Contains(capVPA) && !s.flags.Contains(tRelativeCursor) {
+ yseq = ansi.VerticalPositionAbsolute(ty + 1)
+ }
+
+ if ty > fy {
+ n := ty - fy
+ if cud := ansi.CursorDown(n); yseq == "" || len(cud) < len(yseq) {
+ yseq = cud
+ }
+ if !s.flags.Contains(tFullscreen) || n < len(yseq) { // n is the cost of using newline characters
+ yseq = strings.Repeat("\n", n)
+ if s.flags.Contains(tMapNewline) {
+ fx = 0
+ }
+ }
+ } else if ty < fy {
+ n := fy - ty
+ if cuu := ansi.CursorUp(n); yseq == "" || len(cuu) < len(yseq) {
+ yseq = cuu
+ }
+ if n == 1 && fy-1 > 0 {
+ // TODO: Ensure we're not unintentionally scrolling the screen up.
+ yseq = ansi.ReverseIndex
+ }
+ }
+
+ seq.WriteString(yseq)
+ }
+
+ if tx != fx { //nolint:nestif
+ var xseq string
+ if !s.flags.Contains(tRelativeCursor) {
+ if s.caps.Contains(capHPA) {
+ xseq = ansi.HorizontalPositionAbsolute(tx + 1)
+ } else if s.caps.Contains(capCHA) {
+ xseq = ansi.CursorHorizontalAbsolute(tx + 1)
+ }
+ }
+
+ if tx > fx {
+ n := tx - fx
+ if useTabs && s.tabs != nil {
+ var tabs int
+ var col int
+ for col = fx; s.tabs.Next(col) <= tx; col = s.tabs.Next(col) {
+ tabs++
+ if col == s.tabs.Next(col) || col >= s.tabs.Width()-1 {
+ break
+ }
+ }
+
+ if tabs > 0 {
+ cht := ansi.CursorHorizontalForwardTab(tabs)
+ tab := strings.Repeat("\t", tabs)
+ if false && s.caps.Contains(capCHT) && len(cht) < len(tab) {
+ // TODO: The linux console and some terminals such as
+ // Alacritty don't support [ansi.CHT]. Enable this when
+ // we have a way to detect this, or after 5 years when
+ // we're sure everyone has updated their terminals :P
+ seq.WriteString(cht)
+ } else {
+ seq.WriteString(tab)
+ }
+
+ n = tx - col
+ fx = col
+ }
+ }
+
+ if cuf := ansi.CursorForward(n); xseq == "" || len(cuf) < len(xseq) {
+ xseq = cuf
+ }
+
+ // If we have no attribute and style changes, overwrite is cheaper.
+ var ovw string
+ if overwrite && ty >= 0 {
+ for i := 0; i < n; i++ {
+ cell := newbuf.CellAt(fx+i, ty)
+ if cell != nil && cell.Width > 0 {
+ i += cell.Width - 1
+ if !cell.Style.Equal(&s.cur.Style) || !cell.Link.Equal(&s.cur.Link) {
+ overwrite = false
+ break
+ }
+ }
+ }
+ }
+
+ if overwrite && ty >= 0 {
+ for i := 0; i < n; i++ {
+ cell := newbuf.CellAt(fx+i, ty)
+ if cell != nil && cell.Width > 0 {
+ ovw += cell.String()
+ i += cell.Width - 1
+ } else {
+ ovw += " "
+ }
+ }
+ }
+
+ if overwrite && len(ovw) < len(xseq) {
+ xseq = ovw
+ }
+ } else if tx < fx {
+ n := fx - tx
+ if useTabs && s.tabs != nil && s.caps.Contains(capCBT) {
+ // VT100 does not support backward tabs [ansi.CBT].
+
+ col := fx
+
+ var cbt int // cursor backward tabs count
+ for s.tabs.Prev(col) >= tx {
+ col = s.tabs.Prev(col)
+ cbt++
+ if col == s.tabs.Prev(col) || col <= 0 {
+ break
+ }
+ }
+
+ if cbt > 0 {
+ seq.WriteString(ansi.CursorBackwardTab(cbt))
+ n = col - tx
+ }
+ }
+
+ if cub := ansi.CursorBackward(n); xseq == "" || len(cub) < len(xseq) {
+ xseq = cub
+ }
+
+ if useBackspace && n < len(xseq) {
+ xseq = strings.Repeat("\b", n)
+ }
+ }
+
+ seq.WriteString(xseq)
+ }
+
+ return seq.String()
+}
+
+// moveCursor moves and returns the cursor movement sequence to move the cursor
+// to the specified position.
+// When overwrite is true, this will try to optimize the sequence by using the
+// screen cells values to move the cursor instead of using escape sequences.
+//
+// It is safe to call this function with a nil [Buffer]. In that case, it won't
+// use any optimizations that require the new buffer such as overwrite.
+func moveCursor(s *TerminalRenderer, newbuf *RenderBuffer, x, y int, overwrite bool) (seq string) {
+ fx, fy := s.cur.X, s.cur.Y
+
+ if !s.flags.Contains(tRelativeCursor) {
+ width := -1 // Use -1 to indicate that we don't know the width of the screen.
+ if s.tabs != nil {
+ width = s.tabs.Width()
+ }
+ if newbuf != nil && width == -1 {
+ // Even though this might not be accurate, we can use the new
+ // buffer width as a fallback. Technically, if the new buffer
+ // didn't have the width of the terminal, this would give us a
+ // wrong result from [notLocal].
+ width = newbuf.Width()
+ }
+ // Method #0: Use [ansi.CUP] if the distance is long.
+ seq = ansi.CursorPosition(x+1, y+1)
+ if fx == -1 || fy == -1 || width == -1 || notLocal(width, fx, fy, x, y) {
+ return seq
+ }
+ }
+
+ // Optimize based on options.
+ trials := 0
+ if s.caps.Contains(capHT) {
+ trials |= 2 // 0b10 in binary
+ }
+ if s.caps.Contains(capBS) {
+ trials |= 1 // 0b01 in binary
+ }
+
+ // Try all possible combinations of hard tabs and backspace optimizations.
+ for i := 0; i <= trials; i++ {
+ // Skip combinations that are not enabled.
+ if i & ^trials != 0 {
+ continue
+ }
+
+ useHardTabs := i&2 != 0
+ useBackspace := i&1 != 0
+
+ // Method #1: Use local movement sequences.
+ nseq1 := relativeCursorMove(s, newbuf, fx, fy, x, y, overwrite, useHardTabs, useBackspace)
+ if (i == 0 && len(seq) == 0) || len(nseq1) < len(seq) {
+ seq = nseq1
+ }
+
+ // Method #2: Use [ansi.CR] and local movement sequences.
+ nseq2 := relativeCursorMove(s, newbuf, 0, fy, x, y, overwrite, useHardTabs, useBackspace)
+ nseq2 = "\r" + nseq2
+ if len(nseq2) < len(seq) {
+ seq = nseq2
+ }
+
+ if !s.flags.Contains(tRelativeCursor) {
+ // Method #3: Use [ansi.CursorHomePosition] and local movement sequences.
+ nseq3 := relativeCursorMove(s, newbuf, 0, 0, x, y, overwrite, useHardTabs, useBackspace)
+ nseq3 = ansi.CursorHomePosition + nseq3
+ if len(nseq3) < len(seq) {
+ seq = nseq3
+ }
+ }
+ }
+
+ return seq
+}
+
+// xtermCaps returns whether the terminal is xterm-like. This means that the
+// terminal supports ECMA-48 and ANSI X3.64 escape sequences.
+// xtermCaps returns a list of control sequence capabilities for the given
+// terminal type. This only supports a subset of sequences that can
+// be different among terminals.
+// NOTE: A hybrid approach would be to support Terminfo databases for a full
+// set of capabilities.
+func xtermCaps(termtype string) (v capabilities) {
+ parts := strings.Split(termtype, "-")
+ if len(parts) == 0 {
+ return v
+ }
+
+ switch parts[0] {
+ case
+ "contour",
+ "foot",
+ "ghostty",
+ "kitty",
+ "rio",
+ "st",
+ "tmux",
+ "wezterm":
+ v = allCaps
+ case "xterm":
+ switch {
+ case len(parts) > 1 && parts[1] == "ghostty":
+ fallthrough
+ case len(parts) > 1 && parts[1] == "kitty":
+ fallthrough
+ case len(parts) > 1 && parts[1] == "rio":
+ // These terminals can be defined as xterm- variants for
+ // compatibility with applications that check for xterm.
+ v = allCaps
+ default:
+ // NOTE: We exclude capHPA from allCaps because terminals like
+ // Konsole don't support it. Xterm terminfo defines HPA as CHA
+ // which means we can use CHA instead of HPA.
+ v = allCaps
+ v &^= capHPA
+ v &^= capCHT
+ v &^= capREP
+ }
+ case "alacritty":
+ v = allCaps
+ v &^= capCHT // NOTE: alacritty added support for [ansi.CHT] in 2024-12-28 #62d5b13.
+ case "screen":
+ // See https://www.gnu.org/software/screen/manual/screen.html#Control-Sequences-1
+ v = allCaps
+ v &^= capREP
+ case "linux":
+ // See https://man7.org/linux/man-pages/man4/console_codes.4.html
+ v = capVPA | capCHA | capHPA | capECH | capICH
+ }
+
+ return v
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer_hardscroll.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer_hardscroll.go
new file mode 100644
index 000000000..3b7eb00e4
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer_hardscroll.go
@@ -0,0 +1,243 @@
+package uv
+
+import (
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+// scrollOptimize optimizes the screen to transform the old buffer into the new
+// buffer.
+func (s *TerminalRenderer) scrollOptimize(newbuf *RenderBuffer) {
+ height := newbuf.Height()
+ if s.oldnum == nil || len(s.oldnum) < height {
+ s.oldnum = append(s.oldnum, make([]int, height-len(s.oldnum))...)
+ }
+
+ // Calculate the indices
+ s.updateHashmap(newbuf)
+ if len(s.hashtab) < height {
+ return
+ }
+
+ // Pass 1 - from top to bottom scrolling up
+ for i := 0; i < height; {
+ for i < height && (s.oldnum[i] == newIndex || s.oldnum[i] <= i) {
+ i++
+ }
+ if i >= height {
+ break
+ }
+
+ shift := s.oldnum[i] - i // shift > 0
+ start := i
+
+ i++
+ for i < height && s.oldnum[i] != newIndex && s.oldnum[i]-i == shift {
+ i++
+ }
+ end := i - 1 + shift
+
+ if !s.scrolln(newbuf, shift, start, end, height-1) {
+ continue
+ }
+ }
+
+ // Pass 2 - from bottom to top scrolling down
+ for i := height - 1; i >= 0; {
+ for i >= 0 && (s.oldnum[i] == newIndex || s.oldnum[i] >= i) {
+ i--
+ }
+ if i < 0 {
+ break
+ }
+
+ shift := s.oldnum[i] - i // shift < 0
+ end := i
+
+ i--
+ for i >= 0 && s.oldnum[i] != newIndex && s.oldnum[i]-i == shift {
+ i--
+ }
+
+ start := i + 1 - (-shift)
+ if !s.scrolln(newbuf, shift, start, end, height-1) {
+ continue
+ }
+ }
+}
+
+// scrolln scrolls the screen up by n lines.
+func (s *TerminalRenderer) scrolln(newbuf *RenderBuffer, n, top, bot, maxY int) (v bool) { //nolint:unparam
+ blank := s.clearBlank()
+ if n > 0 { //nolint:nestif
+ // Scroll up (forward)
+ v = s.scrollUp(newbuf, n, top, bot, 0, maxY, blank)
+ if !v {
+ s.buf.WriteString(ansi.SetTopBottomMargins(top+1, bot+1))
+
+ // XXX: How should we handle this in inline mode when not using alternate screen?
+ s.cur.X, s.cur.Y = -1, -1
+ v = s.scrollUp(newbuf, n, top, bot, top, bot, blank)
+ s.buf.WriteString(ansi.SetTopBottomMargins(1, maxY+1))
+ s.cur.X, s.cur.Y = -1, -1
+ }
+
+ if !v {
+ v = s.scrollIdl(newbuf, n, top, bot-n+1, blank)
+ }
+ } else if n < 0 {
+ // Scroll down (backward)
+ v = s.scrollDown(newbuf, -n, top, bot, 0, maxY, blank)
+ if !v {
+ s.buf.WriteString(ansi.SetTopBottomMargins(top+1, bot+1))
+
+ // XXX: How should we handle this in inline mode when not using alternate screen?
+ s.cur.X, s.cur.Y = -1, -1
+ v = s.scrollDown(newbuf, -n, top, bot, top, bot, blank)
+ s.buf.WriteString(ansi.SetTopBottomMargins(1, maxY+1))
+ s.cur.X, s.cur.Y = -1, -1
+
+ if !v {
+ v = s.scrollIdl(newbuf, -n, bot+n+1, top, blank)
+ }
+ }
+ }
+
+ if !v {
+ return false
+ }
+
+ s.scrollBuffer(s.curbuf, n, top, bot, blank)
+
+ // shift hash values too, they can be reused
+ s.scrollOldhash(n, top, bot)
+
+ return true
+}
+
+// scrollBuffer scrolls the buffer by n lines.
+func (s *TerminalRenderer) scrollBuffer(b *RenderBuffer, n, top, bot int, blank *Cell) {
+ if top < 0 || bot < top || bot >= b.Height() {
+ // Nothing to scroll
+ return
+ }
+
+ if n < 0 {
+ // shift n lines downwards
+ limit := top - n
+ for line := bot; line >= limit && line >= 0 && line >= top; line-- {
+ copy(b.Lines[line], b.Lines[line+n])
+ }
+ for line := top; line < limit && line <= b.Height()-1 && line <= bot; line++ {
+ b.FillArea(blank, Rect(0, line, b.Width(), 1))
+ }
+ }
+
+ if n > 0 {
+ // shift n lines upwards
+ limit := bot - n
+ for line := top; line <= limit && line <= b.Height()-1 && line <= bot; line++ {
+ copy(b.Lines[line], b.Lines[line+n])
+ }
+ for line := bot; line > limit && line >= 0 && line >= top; line-- {
+ b.FillArea(blank, Rect(0, line, b.Width(), 1))
+ }
+ }
+
+ s.touchLine(b, top, bot-top+1, true)
+}
+
+// touchLine marks the line as touched.
+func (s *TerminalRenderer) touchLine(newbuf *RenderBuffer, y, n int, changed bool) {
+ height := newbuf.Height()
+ if n < 0 || y < 0 || y >= height || newbuf.Touched == nil || len(newbuf.Touched) < height {
+ return // Nothing to touch
+ }
+
+ width := newbuf.Width()
+ for i := y; i < y+n && i < height && i < len(newbuf.Touched); i++ {
+ if changed {
+ newbuf.TouchLine(0, i, width)
+ } else {
+ newbuf.Touched[i] = nil
+ }
+ }
+}
+
+// scrollUp scrolls the screen up by n lines.
+func (s *TerminalRenderer) scrollUp(newbuf *RenderBuffer, n, top, bot, minY, maxY int, blank *Cell) bool {
+ if n == 1 && top == minY && bot == maxY { //nolint:nestif
+ s.move(newbuf, 0, bot)
+ s.updatePen(blank)
+ s.buf.WriteByte('\n')
+ } else if n == 1 && bot == maxY {
+ s.move(newbuf, 0, top)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.DeleteLine(1))
+ } else if top == minY && bot == maxY {
+ supportsSU := s.caps.Contains(capSU)
+ s.move(newbuf, 0, bot)
+ s.updatePen(blank)
+ if supportsSU {
+ s.buf.WriteString(ansi.ScrollUp(n))
+ } else {
+ s.buf.WriteString(strings.Repeat("\n", n))
+ }
+ } else if bot == maxY {
+ s.move(newbuf, 0, top)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.DeleteLine(n))
+ } else {
+ return false
+ }
+ return true
+}
+
+// scrollDown scrolls the screen down by n lines.
+func (s *TerminalRenderer) scrollDown(newbuf *RenderBuffer, n, top, bot, minY, maxY int, blank *Cell) bool {
+ if n == 1 && top == minY && bot == maxY { //nolint:nestif
+ s.move(newbuf, 0, top)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.ReverseIndex)
+ } else if n == 1 && bot == maxY {
+ s.move(newbuf, 0, top)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.InsertLine(1))
+ } else if top == minY && bot == maxY {
+ s.move(newbuf, 0, top)
+ s.updatePen(blank)
+ if s.caps.Contains(capSD) {
+ s.buf.WriteString(ansi.ScrollDown(n))
+ } else {
+ s.buf.WriteString(strings.Repeat(ansi.ReverseIndex, n))
+ }
+ } else if bot == maxY {
+ s.move(newbuf, 0, top)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.InsertLine(n))
+ } else {
+ return false
+ }
+ return true
+}
+
+// scrollIdl scrolls the screen n lines by using [ansi.DL] at del and using
+// [ansi.IL] at ins.
+func (s *TerminalRenderer) scrollIdl(newbuf *RenderBuffer, n, del, ins int, blank *Cell) bool {
+ if n < 0 {
+ return false
+ }
+
+ // Delete lines
+ s.move(newbuf, 0, del)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.DeleteLine(n))
+
+ // Insert lines
+ s.move(newbuf, 0, ins)
+ s.updatePen(blank)
+ s.buf.WriteString(ansi.InsertLine(n))
+
+ return true
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer_hashmap.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer_hashmap.go
new file mode 100644
index 000000000..ad776ff83
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_renderer_hashmap.go
@@ -0,0 +1,298 @@
+package uv
+
+import "hash/maphash"
+
+// hash returns the hash value of a [Line].
+func hash(h *maphash.Hash, l Line) uint64 {
+ h.Reset()
+ for _, c := range l {
+ // maphash writes can not fail
+ _, _ = h.WriteString(c.Content)
+ }
+
+ return h.Sum64()
+}
+
+// hashmap represents a single [Line] hash.
+type hashmap struct {
+ value uint64
+ oldcount, newcount int
+ oldindex, newindex int
+}
+
+// The value used to indicate lines created by insertions and scrolls.
+const newIndex = -1
+
+// updateHashmap updates the hashmap with the new hash value.
+func (s *TerminalRenderer) updateHashmap(newbuf *RenderBuffer) {
+ height := newbuf.Height()
+
+ if len(s.oldhash) >= height && len(s.newhash) >= height {
+ // rehash changed lines
+ for i := range height {
+ if newbuf.Touched == nil || newbuf.Touched[i] != nil {
+ // TODO: Investigate why this is needed. If we remove this
+ // line, scroll optimization does not work correctly. This
+ // should happen else where.
+ s.oldhash[i] = hash(&s.hasher, s.curbuf.Line(i))
+ s.newhash[i] = hash(&s.hasher, newbuf.Line(i))
+ }
+ }
+ } else {
+ // rehash all
+ if len(s.oldhash) != height {
+ s.oldhash = make([]uint64, height)
+ }
+ if len(s.newhash) != height {
+ s.newhash = make([]uint64, height)
+ }
+ for i := range height {
+ s.oldhash[i] = hash(&s.hasher, s.curbuf.Line(i))
+ s.newhash[i] = hash(&s.hasher, newbuf.Line(i))
+ }
+ }
+
+ s.hashtab = make([]hashmap, (height+1)*2)
+ for i := range height {
+ hashval := s.oldhash[i]
+
+ // Find matching hash or empty slot
+ var idx int
+ for idx = 0; idx < len(s.hashtab) && s.hashtab[idx].value != 0; idx++ {
+ if s.hashtab[idx].value == hashval {
+ break
+ }
+ }
+
+ s.hashtab[idx].value = hashval // in case this is a new hash
+ s.hashtab[idx].oldcount++
+ s.hashtab[idx].oldindex = i
+ }
+ for i := range height {
+ hashval := s.newhash[i]
+
+ // Find matching hash or empty slot
+ var idx int
+ for idx = 0; idx < len(s.hashtab) && s.hashtab[idx].value != 0; idx++ {
+ if s.hashtab[idx].value == hashval {
+ break
+ }
+ }
+
+ s.hashtab[idx].value = hashval // in case this is a new hash
+ s.hashtab[idx].newcount++
+ s.hashtab[idx].newindex = i
+ s.oldnum[i] = newIndex // init old indices slice
+ }
+
+ // Mark line pair corresponding to unique hash pairs.
+ for i := 0; i < len(s.hashtab) && s.hashtab[i].value != 0; i++ {
+ hsp := &s.hashtab[i]
+ if hsp.oldcount == 1 && hsp.newcount == 1 && hsp.oldindex != hsp.newindex {
+ s.oldnum[hsp.newindex] = hsp.oldindex
+ }
+ }
+
+ s.growHunks(newbuf)
+
+ // Eliminate bad or impossible shifts. This includes removing those hunks
+ // which could not grow because of conflicts, as well those which are to be
+ // moved too far, they are likely to destroy more than carry.
+ for i := 0; i < height; {
+ var start, shift, size int
+ for i < height && s.oldnum[i] == newIndex {
+ i++
+ }
+ if i >= height {
+ break
+ }
+ start = i
+ shift = s.oldnum[i] - i
+ i++
+ for i < height && s.oldnum[i] != newIndex && s.oldnum[i]-i == shift {
+ i++
+ }
+ size = i - start
+ if size < 3 || size+min(size/8, 2) < abs(shift) {
+ for start < i {
+ s.oldnum[start] = newIndex
+ start++
+ }
+ }
+ }
+
+ // After clearing invalid hunks, try grow the rest.
+ s.growHunks(newbuf)
+}
+
+// scrollOldhash scrolls the oldhash slice by 'n' lines between 'top' and 'bot'.
+func (s *TerminalRenderer) scrollOldhash(n, top, bot int) {
+ if len(s.oldhash) == 0 {
+ return
+ }
+
+ size := bot - top + 1 - abs(n)
+ if n > 0 {
+ // Move existing hashes up
+ copy(s.oldhash[top:], s.oldhash[top+n:top+n+size])
+ // Recalculate hashes for newly shifted-in lines
+ for i := bot; i > bot-n; i-- {
+ s.oldhash[i] = hash(&s.hasher, s.curbuf.Line(i))
+ }
+ } else {
+ // Move existing hashes down
+ copy(s.oldhash[top-n:], s.oldhash[top:top+size])
+ // Recalculate hashes for newly shifted-in lines
+ for i := top; i < top-n; i++ {
+ s.oldhash[i] = hash(&s.hasher, s.curbuf.Line(i))
+ }
+ }
+}
+
+func (s *TerminalRenderer) growHunks(newbuf *RenderBuffer) {
+ var (
+ backLimit int // limits for cells to fill
+ backRefLimit int // limit for references
+ i int
+ nextHunk int
+ )
+
+ height := newbuf.Height()
+ for i < height && s.oldnum[i] == newIndex {
+ i++
+ }
+ for ; i < height; i = nextHunk {
+ var (
+ forwardLimit int
+ forwardRefLimit int
+ end int
+ start = i
+ shift = s.oldnum[i] - i
+ )
+
+ // get forward limit
+ i = start + 1
+ for i < height &&
+ s.oldnum[i] != newIndex &&
+ s.oldnum[i]-i == shift {
+ i++
+ }
+
+ end = i
+ for i < height && s.oldnum[i] == newIndex {
+ i++
+ }
+
+ nextHunk = i
+ forwardLimit = i
+ if i >= height || s.oldnum[i] >= i {
+ forwardRefLimit = i
+ } else {
+ forwardRefLimit = s.oldnum[i]
+ }
+
+ i = start - 1
+
+ // grow back
+ if shift < 0 {
+ backLimit = backRefLimit + (-shift)
+ }
+ for i >= backLimit {
+ if s.newhash[i] == s.oldhash[i+shift] ||
+ s.costEffective(newbuf, i+shift, i, shift < 0) {
+ s.oldnum[i] = i + shift
+ } else {
+ break
+ }
+ i--
+ }
+
+ i = end
+ // grow forward
+ if shift > 0 {
+ forwardLimit = forwardRefLimit - shift
+ }
+ for i < forwardLimit {
+ if s.newhash[i] == s.oldhash[i+shift] ||
+ s.costEffective(newbuf, i+shift, i, shift > 0) {
+ s.oldnum[i] = i + shift
+ } else {
+ break
+ }
+ i++
+ }
+
+ backLimit = i
+ backRefLimit = backLimit
+ if shift > 0 {
+ backRefLimit += shift
+ }
+ }
+}
+
+// costEffective returns true if the cost of moving line 'from' to line 'to' seems to be
+// cost effective. 'blank' indicates whether the line 'to' would become blank.
+func (s *TerminalRenderer) costEffective(newbuf *RenderBuffer, from, to int, blank bool) bool {
+ if from == to {
+ return false
+ }
+
+ newFrom := s.oldnum[from]
+ if newFrom == newIndex {
+ newFrom = from
+ }
+
+ // On the left side of >= is the cost before moving. On the right side --
+ // cost after moving.
+
+ // Calculate costs before moving.
+ var costBeforeMove int
+ if blank {
+ // Cost of updating blank line at destination.
+ costBeforeMove = s.updateCostBlank(newbuf, newbuf.Line(to))
+ } else {
+ // Cost of updating exiting line at destination.
+ costBeforeMove = s.updateCost(newbuf, s.curbuf.Line(to), newbuf.Line(to))
+ }
+
+ // Add cost of updating source line
+ costBeforeMove += s.updateCost(newbuf, s.curbuf.Line(newFrom), newbuf.Line(from))
+
+ // Calculate costs after moving.
+ var costAfterMove int
+ if newFrom == from {
+ // Source becomes blank after move
+ costAfterMove = s.updateCostBlank(newbuf, newbuf.Line(from))
+ } else {
+ // Source gets updated from another line
+ costAfterMove = s.updateCost(newbuf, s.curbuf.Line(newFrom), newbuf.Line(from))
+ }
+
+ // Add cost of moving source line to destination
+ costAfterMove += s.updateCost(newbuf, s.curbuf.Line(from), newbuf.Line(to))
+
+ // Return true if moving is cost effective (costs less or equal)
+ return costBeforeMove >= costAfterMove
+}
+
+func (s *TerminalRenderer) updateCost(_ *RenderBuffer, from, to Line) (cost int) {
+ var fidx, tidx int
+ for i := s.curbuf.Width(); i > 0; i, fidx, tidx = i-1, fidx+1, tidx+1 {
+ if !cellEqual(from.At(fidx), to.At(tidx)) {
+ cost++
+ }
+ }
+ return
+}
+
+func (s *TerminalRenderer) updateCostBlank(_ *RenderBuffer, to Line) (cost int) {
+ // This assumes bce capability.
+ blank := s.clearBlank()
+ var tidx int
+ for i := s.curbuf.Width(); i > 0; i, tidx = i-1, tidx+1 {
+ if !cellEqual(blank, to.At(tidx)) {
+ cost++
+ }
+ }
+ return
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_screen.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_screen.go
new file mode 100644
index 000000000..ae79963f5
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_screen.go
@@ -0,0 +1,825 @@
+package uv
+
+import (
+ "bytes"
+ "image/color"
+ "io"
+ "log"
+ "os"
+ "strings"
+
+ "github.com/charmbracelet/colorprofile"
+ "github.com/charmbracelet/x/ansi"
+ "github.com/charmbracelet/x/term"
+)
+
+// TerminalScreen represents a terminal screen, providing methods for managing
+// the screen state and rendering content.
+type TerminalScreen struct {
+ win *Window
+ w io.Writer
+ buf *bytes.Buffer
+ rend *TerminalRenderer
+ rbuf *RenderBuffer
+ env Environ
+ profile colorprofile.Profile
+
+ // Terminal state
+ altScreen bool
+ keyboardEnhancements *KeyboardEnhancements
+ bracketedPaste bool
+ mouseMode MouseMode
+ cursor *Cursor // initial state is cursor hidden
+ backgroundColor color.Color
+ foregroundColor color.Color
+ progressBar *ProgressBar
+ windowTitle string
+ syncUpdates bool // mode 2026
+}
+
+var _ Screen = (*TerminalScreen)(nil)
+
+// NewTerminalScreen creates a new [TerminalScreen] with the given writer and environment.
+func NewTerminalScreen(w io.Writer, env Environ) *TerminalScreen {
+ s := &TerminalScreen{}
+ s.buf = &bytes.Buffer{}
+ s.win = NewScreen(0, 0)
+ s.w = w
+ s.profile = colorprofile.Detect(w, env)
+ s.rend = NewTerminalRenderer(s.buf, env)
+ s.rend.SetFullscreen(false) // by default, we start in inline mode
+ s.rend.SetRelativeCursor(true) // by default, we start in inline mode
+ s.rend.SetColorProfile(s.profile)
+ s.rbuf = NewRenderBuffer(0, 0)
+ s.env = env
+
+ if debugFile := env.Getenv("UV_DEBUG"); debugFile != "" {
+ if f, err := os.OpenFile(debugFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644); err == nil {
+ log.SetOutput(f)
+ s.rend.SetLogger(log.Default())
+ }
+ }
+
+ // Configure renderer optimizations based on console settings.
+ f, ok := w.(term.File)
+ if ok {
+ state, err := term.GetState(f.Fd())
+ if err == nil {
+ useTabs, useBspace := optimizeMovements(state)
+ if useTabs {
+ s.rend.SetTabStops(0) // the width will be set after calling [TerminalScreen.Resize]
+ }
+ s.rend.SetBackspace(useBspace)
+ }
+ }
+ // XXX: Do we still need map nl to crlf handling in the renderer?
+ s.rend.SetMapNewline(false)
+ return s
+}
+
+// CellAt returns the cell at the specified x and y coordinates.
+func (s *TerminalScreen) CellAt(x, y int) *Cell {
+ return s.win.CellAt(x, y)
+}
+
+// SetCell sets the cell at the specified x and y coordinates.
+func (s *TerminalScreen) SetCell(x, y int, cell *Cell) {
+ s.win.SetCell(x, y, cell)
+}
+
+// Bounds returns the bounds of the terminal screen as a rectangle.
+func (s *TerminalScreen) Bounds() Rectangle {
+ return s.win.Bounds()
+}
+
+// WidthMethod returns the width method used by the terminal screen.
+func (s *TerminalScreen) WidthMethod() WidthMethod {
+ return s.win.WidthMethod()
+}
+
+// SetWidthMethod sets the width method for the terminal screen.
+func (s *TerminalScreen) SetWidthMethod(method ansi.Method) {
+ s.win.SetWidthMethod(method)
+}
+
+// SetColorProfile sets the color profile for the terminal screen.
+// This is automatically detected when creating the terminal screen. However,
+// you can override it using this method.
+func (s *TerminalScreen) SetColorProfile(profile colorprofile.Profile) {
+ s.profile = profile
+ s.rend.SetColorProfile(profile)
+}
+
+// Resize resizes the terminal screen to the specified width and height,
+// updating the render buffer and renderer accordingly.
+func (s *TerminalScreen) Resize(width, height int) error {
+ s.win.Resize(width, height)
+ s.rbuf.Resize(width, height)
+ s.rend.Resize(width, height)
+ s.rend.Erase()
+ s.rbuf.Touched = nil
+ return nil
+}
+
+// Display clears the screen and draws the given [Drawable] onto the terminal
+// screen and flushes the changes to the underlying writer.
+//
+// This is a convenience method that combines [TerminalScreen.Render] and
+// [TerminalScreen.Flush].
+func (s *TerminalScreen) Display(d Drawable) error {
+ if d != nil {
+ s.win.Clear()
+ d.Draw(s, s.win.Bounds())
+ }
+ if err := s.Render(); err != nil {
+ return err
+ }
+ return s.Flush()
+}
+
+// Render renders changes that transform the screen from its current state to
+// the state represented by the [TerminalScreen].
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) Render() error {
+ for y := 0; y < s.win.Height(); y++ {
+ for x := 0; x < s.win.Width(); {
+ cell := s.win.CellAt(x, y)
+ if cell == nil || cell.IsZero() {
+ x++
+ continue
+ }
+ s.rbuf.SetCell(x, y, cell)
+ width := cell.Width
+ if width <= 0 {
+ width = 1
+ }
+ x += width
+ }
+ }
+ s.rend.Render(s.rbuf)
+ return s.rend.Flush()
+}
+
+// Flush writes any pending output to the underlying writer.
+func (s *TerminalScreen) Flush() error {
+ if s.cursor != nil && !s.cursor.Hidden && s.cursor.X >= 0 && s.cursor.Y >= 0 {
+ s.rend.MoveTo(s.cursor.X, s.cursor.Y)
+ } else if !s.altScreen {
+ // We don't want the cursor to be dangling at the end of the line in
+ // inline mode because it can cause unwanted line wraps in some
+ // terminals. So we move it to the beginning of the next line if
+ // necessary.
+ // This is only needed when the cursor is hidden because when it's
+ // visible, we already set its position above.
+ x, y := s.rend.Position()
+ if x >= s.win.Width()-1 {
+ s.rend.MoveTo(0, y)
+ }
+ }
+
+ var buf bytes.Buffer
+ buf.Grow(s.buf.Len())
+
+ if s.buf.Len() > 0 {
+ if s.syncUpdates {
+ buf.Grow(len(ansi.SetModeSynchronizedOutput) + len(ansi.ResetModeSynchronizedOutput))
+
+ // If synchronized updates are enabled, we need to wrap the output in
+ // the appropriate control sequences to ensure that the terminal treats
+ // it as a single atomic update. This is necessary to prevent flickering
+ // and other visual artifacts that can occur when multiple updates are sent
+ // separately.
+ buf.WriteString(ansi.SetModeSynchronizedOutput)
+ } else if s.cursor != nil && !s.cursor.Hidden {
+ buf.Grow(len(ansi.HideCursor) + len(ansi.ShowCursor))
+
+ // If synchronized updates are not enabled, we need to ensure that
+ // the cursor is hidden before writing any output to prevent
+ // unwanted cursor visual artifacts.
+ buf.WriteString(ansi.HideCursor)
+ }
+
+ buf.Write(s.buf.Bytes())
+
+ if s.syncUpdates {
+ buf.WriteString(ansi.ResetModeSynchronizedOutput)
+ } else if s.cursor != nil && !s.cursor.Hidden {
+ buf.WriteString(ansi.ShowCursor)
+ }
+ }
+
+ _, err := s.w.Write(buf.Bytes())
+ if err != nil {
+ return err
+ }
+ s.buf.Reset()
+ return nil
+}
+
+// EnterAltScreen switches the terminal to the alternate screen buffer, allowing
+// applications to use a separate screen for their output without affecting the
+// main screen.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) EnterAltScreen() error {
+ var sb strings.Builder
+ sb.WriteString(ansi.SetModeAltScreenSaveCursor)
+ if s.cursor == nil || s.cursor.Hidden {
+ sb.WriteString(ansi.HideCursor)
+ } else if s.cursor != nil && !s.cursor.Hidden {
+ sb.WriteString(ansi.ShowCursor)
+ }
+ if s.keyboardEnhancements != nil {
+ _ = EncodeKeyboardEnhancements(&sb, s.keyboardEnhancements)
+ }
+ _, err := s.buf.WriteString(sb.String())
+ if err != nil {
+ return err
+ }
+
+ if !s.altScreen {
+ s.rend.SaveCursor()
+ s.rend.Erase()
+ s.rend.SetFullscreen(true)
+ s.rend.SetRelativeCursor(false)
+ s.altScreen = true
+ }
+
+ return nil
+}
+
+// ExitAltScreen switches the terminal back to the main screen buffer, restoring
+// the previous screen state.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) ExitAltScreen() error {
+ var sb strings.Builder
+ sb.WriteString(ansi.ResetModeAltScreenSaveCursor)
+ if s.cursor == nil || s.cursor.Hidden {
+ sb.WriteString(ansi.HideCursor)
+ } else if s.cursor != nil && !s.cursor.Hidden {
+ sb.WriteString(ansi.ShowCursor)
+ }
+ if s.keyboardEnhancements != nil {
+ _ = EncodeKeyboardEnhancements(&sb, s.keyboardEnhancements)
+ }
+ _, err := s.buf.WriteString(sb.String())
+ if err != nil {
+ return err
+ }
+
+ if s.altScreen {
+ s.rend.RestoreCursor()
+ s.rend.Erase()
+ s.rend.SetFullscreen(false)
+ s.rend.SetRelativeCursor(true)
+ s.altScreen = false
+ }
+
+ return nil
+}
+
+// AltScreen returns whether the terminal is currently in the alternate screen
+// buffer.
+func (s *TerminalScreen) AltScreen() bool {
+ return s.altScreen
+}
+
+// HideCursor hides the terminal cursor.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) HideCursor() error {
+ _, err := s.buf.WriteString(ansi.HideCursor)
+ if err != nil {
+ return err
+ }
+
+ if s.cursor != nil {
+ s.cursor.Hidden = true
+ }
+
+ return nil
+}
+
+// ShowCursor shows the terminal cursor.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) ShowCursor() error {
+ _, err := s.buf.WriteString(ansi.ShowCursor)
+ if err != nil {
+ return err
+ }
+
+ if s.cursor != nil {
+ s.cursor.Hidden = false
+ } else {
+ s.cursor = NewCursor(-1, -1)
+ }
+
+ return nil
+}
+
+// CursorVisible returns whether the terminal cursor is currently visible.
+func (s *TerminalScreen) CursorVisible() bool {
+ return s.cursor != nil && !s.cursor.Hidden
+}
+
+// SetCursorPosition sets the position of the terminal cursor to the specified
+// coordinates.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetCursorPosition(x, y int) error {
+ if s.cursor == nil {
+ s.cursor = NewCursor(x, y)
+ s.cursor.Hidden = true
+ } else {
+ s.cursor.X = x
+ s.cursor.Y = y
+ }
+ return nil
+}
+
+// CursorPosition returns the last set cursor position of the terminal. If the
+// cursor position is not set, it returns (-1, -1).
+//
+// This can be affected by [TerminalScreen.Render] and
+// [TerminalScreen.SetCursorPosition] calls.
+func (s *TerminalScreen) CursorPosition() (x, y int) {
+ if s.cursor != nil {
+ return s.cursor.X, s.cursor.Y
+ }
+ return -1, -1
+}
+
+// SetCursorStyle sets the style of the terminal cursor.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetCursorStyle(shape CursorShape, blink bool) error {
+ if err := EncodeCursorStyle(s.buf, shape, blink); err != nil {
+ return err
+ }
+
+ if s.cursor == nil {
+ s.cursor = NewCursor(-1, -1)
+ }
+ s.cursor.Shape = shape
+ s.cursor.Blink = blink
+
+ return nil
+}
+
+// CursorStyle returns the current style of the terminal cursor.
+func (s *TerminalScreen) CursorStyle() (shape CursorShape, blink bool) {
+ if s.cursor != nil {
+ return s.cursor.Shape, s.cursor.Blink
+ }
+ return CursorBlock, true
+}
+
+// SetCursorColor sets the color of the terminal cursor.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetCursorColor(c color.Color) error {
+ if err := EncodeCursorColor(s.buf, c); err != nil {
+ return err
+ }
+
+ if s.cursor == nil {
+ s.cursor = NewCursor(-1, -1)
+ }
+ s.cursor.Color = c
+
+ return nil
+}
+
+// CursorColor returns the current color of the terminal cursor.
+//
+// A nil color indicates that the cursor color is the default terminal cursor
+// color.
+func (s *TerminalScreen) CursorColor() color.Color {
+ if s.cursor != nil {
+ return s.cursor.Color
+ }
+ return nil
+}
+
+// SetBackgroundColor sets the background color of the terminal.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetBackgroundColor(c color.Color) error {
+ if err := EncodeBackgroundColor(s.buf, c); err != nil {
+ return err
+ }
+
+ s.backgroundColor = c
+
+ return nil
+}
+
+// BackgroundColor returns the current background color of the terminal.
+//
+// A nil color indicates that the background color is the default terminal
+// background color.
+func (s *TerminalScreen) BackgroundColor() color.Color {
+ return s.backgroundColor
+}
+
+// SetForegroundColor sets the foreground color of the terminal.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetForegroundColor(c color.Color) error {
+ if err := EncodeForegroundColor(s.buf, c); err != nil {
+ return err
+ }
+
+ s.foregroundColor = c
+
+ return nil
+}
+
+// ForegroundColor returns the current foreground color of the terminal.
+//
+// A nil color indicates that the foreground color is the default terminal
+// foreground color.
+func (s *TerminalScreen) ForegroundColor() color.Color {
+ return s.foregroundColor
+}
+
+// EnableBracketedPaste enables bracketed paste mode, allowing the terminal to
+// distinguish between pasted content and user input.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) EnableBracketedPaste() error {
+ _, err := s.buf.WriteString(ansi.SetModeBracketedPaste)
+ if err != nil {
+ return err
+ }
+
+ s.bracketedPaste = true
+
+ return nil
+}
+
+// DisableBracketedPaste disables bracketed paste mode.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) DisableBracketedPaste() error {
+ _, err := s.buf.WriteString(ansi.ResetModeBracketedPaste)
+ if err != nil {
+ return err
+ }
+
+ s.bracketedPaste = false
+
+ return nil
+}
+
+// BracketedPaste returns whether bracketed paste mode is currently enabled.
+func (s *TerminalScreen) BracketedPaste() bool {
+ return s.bracketedPaste
+}
+
+// SetSynchronizedUpdates sets whether to use synchronized updates (mode 2026),
+// which allows applications to batch updates to the terminal screen and flush
+// them all at once for improved performance.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetSynchronizedUpdates(enabled bool) error {
+ s.syncUpdates = enabled
+ return nil
+}
+
+// SynchronizedUpdates returns whether synchronized updates (mode 2026) are
+// currently enabled.
+func (s *TerminalScreen) SynchronizedUpdates() bool {
+ return s.syncUpdates
+}
+
+// SetMouseMode sets the mouse mode for the terminal, allowing applications to
+// receive mouse events.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetMouseMode(mode MouseMode) error {
+ if err := EncodeMouseMode(s.buf, mode); err != nil {
+ return err
+ }
+
+ s.mouseMode = mode
+
+ return nil
+}
+
+// MouseMode returns the current mouse mode of the terminal.
+func (s *TerminalScreen) MouseMode() MouseMode {
+ return s.mouseMode
+}
+
+// SetWindowTitle sets the title of the terminal window.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetWindowTitle(title string) error {
+ if err := EncodeWindowTitle(s.buf, title); err != nil {
+ return err
+ }
+
+ s.windowTitle = title
+
+ return nil
+}
+
+// WindowTitle returns the current title of the terminal window.
+func (s *TerminalScreen) WindowTitle() string {
+ return s.windowTitle
+}
+
+// SetKeyboardEnhancements sets the keyboard enhancements for the terminal,
+// allowing applications to receive enhanced keyboard input.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetKeyboardEnhancements(enh *KeyboardEnhancements) error {
+ if err := EncodeKeyboardEnhancements(s.buf, enh); err != nil {
+ return err
+ }
+
+ s.keyboardEnhancements = enh
+
+ return nil
+}
+
+// KeyboardEnhancements returns the current keyboard enhancements of the terminal.
+//
+// A nil value indicates that no keyboard enhancements are currently enabled.
+func (s *TerminalScreen) KeyboardEnhancements() *KeyboardEnhancements {
+ return s.keyboardEnhancements
+}
+
+// SetProgressBar sets the progress bar for the terminal, allowing applications
+// to display progress information.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) SetProgressBar(pb *ProgressBar) error {
+ if err := EncodeProgressBar(s.buf, pb); err != nil {
+ return err
+ }
+
+ s.progressBar = pb
+
+ return nil
+}
+
+// ProgressBar returns the current progress bar of the terminal.
+//
+// A nil value indicates that no progress bar is currently set.
+func (s *TerminalScreen) ProgressBar() *ProgressBar {
+ return s.progressBar
+}
+
+// Reset resets the terminal screen to its default state, clearing the screen,
+// switching back to the main screen buffer if necessary, and resetting all
+// terminal settings to their defaults.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) Reset() error {
+ var sb strings.Builder
+
+ hasKeyboardEnhancements := s.keyboardEnhancements != nil
+
+ if s.altScreen {
+ if hasKeyboardEnhancements {
+ sb.WriteString(ansi.KittyKeyboard(0, 1))
+ }
+ sb.WriteString(ansi.ResetModeAltScreenSaveCursor)
+ }
+ if hasKeyboardEnhancements {
+ sb.WriteString(ansi.KittyKeyboard(0, 1))
+ }
+ if s.mouseMode != MouseModeNone {
+ _ = EncodeMouseMode(&sb, MouseModeNone)
+ }
+
+ if s.cursor == nil || !s.cursor.Hidden {
+ sb.WriteString(ansi.ShowCursor)
+ }
+ if s.cursor != nil {
+ if s.cursor.Shape != CursorBlock || !s.cursor.Blink {
+ sb.WriteString(ansi.SetCursorStyle(0))
+ }
+ if s.cursor.Color != nil {
+ sb.WriteString(ansi.ResetCursorColor)
+ }
+ }
+ if s.backgroundColor != nil {
+ sb.WriteString(ansi.ResetBackgroundColor)
+ }
+ if s.foregroundColor != nil {
+ sb.WriteString(ansi.ResetForegroundColor)
+ }
+ if s.bracketedPaste {
+ sb.WriteString(ansi.ResetModeBracketedPaste)
+ }
+ if s.windowTitle != "" {
+ sb.WriteString(ansi.SetWindowTitle(""))
+ }
+ if s.progressBar != nil && s.progressBar.State != ProgressBarNone {
+ sb.WriteString(ansi.ResetProgressBar)
+ }
+
+ _, err := s.buf.WriteString(sb.String())
+ if err != nil {
+ return err
+ }
+
+ // Go to the bottom of the screen.
+ // We need to go to the bottom of the screen regardless of whether
+ // we're in alt screen mode or not to avoid leaving the cursor in the
+ // middle in terminals that don't support alt screen mode.
+ //
+ // This comes after resetting the screen state to ensure that moving the
+ // cursor is the last thing we do, preventing any unwanted cursor movements
+ // after resetting the screen.
+ //
+ // Note that both [TerminalScreen.rend] writes to [TerminalScreen.buf].
+ s.rend.MoveTo(0, s.win.Height()-1)
+
+ return nil
+}
+
+// Restore restores the terminal screen to its previous state, applying any
+// previous settings and state that were reset by the [TerminalScreen.Reset] method.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) Restore() error {
+ var sb strings.Builder
+
+ if s.altScreen {
+ sb.WriteString(ansi.SetModeAltScreenSaveCursor)
+ }
+ if s.cursor != nil && !s.cursor.Hidden {
+ sb.WriteString(ansi.ShowCursor)
+ } else {
+ // Hide the cursor by default.
+ sb.WriteString(ansi.HideCursor)
+ }
+ if s.keyboardEnhancements != nil {
+ if err := EncodeKeyboardEnhancements(&sb, s.keyboardEnhancements); err != nil {
+ return err
+ }
+ }
+ if s.mouseMode != MouseModeNone {
+ if err := EncodeMouseMode(&sb, s.mouseMode); err != nil {
+ return err
+ }
+ }
+ if s.cursor != nil {
+ if s.cursor.Shape != CursorBlock || !s.cursor.Blink {
+ _ = EncodeCursorStyle(&sb, s.cursor.Shape, s.cursor.Blink)
+ }
+ if s.cursor.Color != nil {
+ if err := EncodeCursorColor(&sb, s.cursor.Color); err != nil {
+ return err
+ }
+ }
+ }
+ if s.backgroundColor != nil {
+ if err := EncodeBackgroundColor(&sb, s.backgroundColor); err != nil {
+ return err
+ }
+ }
+ if s.foregroundColor != nil {
+ if err := EncodeForegroundColor(&sb, s.foregroundColor); err != nil {
+ return err
+ }
+ }
+ if s.bracketedPaste {
+ sb.WriteString(ansi.SetModeBracketedPaste)
+ }
+ if s.windowTitle != "" {
+ if err := EncodeWindowTitle(&sb, s.windowTitle); err != nil {
+ return err
+ }
+ }
+ if s.progressBar != nil && s.progressBar.State != ProgressBarNone {
+ if err := EncodeProgressBar(&sb, s.progressBar); err != nil {
+ return err
+ }
+ }
+
+ _, err := s.buf.WriteString(sb.String())
+ if err != nil {
+ return err
+ }
+
+ // This needs to be called after restoring the screen state and writing to
+ // the buffer.
+ //
+ // [TerminalScreen.Render] will write to [TerminalScreen.buf], so we need
+ // to call it after writing the restore commands to the buffer to ensure
+ // that the restore commands are included in the render output. This
+ // ensures that the screen is properly restored before rendering any
+ // changes.
+ if err := s.Render(); err != nil {
+ return err
+ }
+
+ // Cursor position will be restored by the caller after calling
+ // [TerminalScreen.Flush].
+
+ return nil
+}
+
+// Write writes data to the underlying buffer queuing it for output.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) Write(p []byte) (n int, err error) {
+ return s.buf.Write(p)
+}
+
+// WriteString writes a string to the underlying buffer queuing it for output.
+//
+// The changes can be committed to the underlying writer by calling the
+// [TerminalScreen.Flush] method.
+func (s *TerminalScreen) WriteString(str string) (n int, err error) {
+ return s.buf.WriteString(str)
+}
+
+// InsertAbove inserts content above the screen pushing the current content
+// down.
+//
+// This is useful for inserting content above the current screen content
+// without affecting the current cursor position or screen state.
+//
+// Note that this won't have any visible effect if the screen is in alt screen
+// mode, as the content will be inserted above the alt screen buffer, which is
+// not visible. However, if the screen is in inline mode, the content will be
+// inserted above and will not be managed by the renderer.
+//
+// Unlike other methods that modify the screen state, this method writes
+// directly to the underlying writer, so there is no need to call
+// [TerminalScreen.Flush] after calling this method.
+func (s *TerminalScreen) InsertAbove(content string) error {
+ if len(content) == 0 {
+ return nil
+ }
+
+ var sb strings.Builder
+ w, h := s.win.Width(), s.win.Height()
+ _, y := s.rend.Position()
+
+ // We need to scroll the screen up by the number of lines in the queue.
+ sb.WriteByte('\r')
+ down := h - y - 1
+ if down > 0 {
+ sb.WriteString(ansi.CursorDown(down))
+ }
+
+ lines := strings.Split(content, "\n")
+ offset := len(lines)
+ for _, line := range lines {
+ lineWidth := s.win.WidthMethod().StringWidth(line)
+ if w > 0 && lineWidth > w {
+ offset += (lineWidth / w)
+ }
+ }
+
+ // Scroll the screen up by the offset to make room for the new lines.
+ sb.WriteString(strings.Repeat("\n", offset))
+
+ // XXX: Now go to the top of the screen, insert new lines, and write
+ // the queued strings. It is important to use [Screen.moveCursor]
+ // instead of [Screen.move] because we don't want to perform any checks
+ // on the cursor position.
+ up := offset + h - 1
+ sb.WriteString(ansi.CursorUp(up))
+ sb.WriteString(ansi.InsertLine(offset))
+ for _, line := range lines {
+ sb.WriteString(line)
+ sb.WriteString(ansi.EraseLineRight)
+ sb.WriteString("\r\n")
+ }
+
+ s.rend.SetPosition(0, 0)
+
+ _, err := io.WriteString(s.w, sb.String())
+ return err
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_tabdly.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_tabdly.go
new file mode 100644
index 000000000..52c47a225
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_tabdly.go
@@ -0,0 +1,10 @@
+//go:build darwin || linux || freebsd || solaris || aix
+// +build darwin linux freebsd solaris aix
+
+package uv
+
+import "golang.org/x/sys/unix"
+
+func supportsHardTabs(oflag uint64) bool {
+ return oflag&unix.TABDLY == unix.TAB0
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_tabdly_other.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_tabdly_other.go
new file mode 100644
index 000000000..30b1914c6
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_tabdly_other.go
@@ -0,0 +1,8 @@
+//go:build !darwin && !linux && !freebsd && !solaris && !aix && !windows
+// +build !darwin,!linux,!freebsd,!solaris,!aix,!windows
+
+package uv
+
+func supportsHardTabs(uint64) bool {
+ return false
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_unix.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_unix.go
new file mode 100644
index 000000000..9caf0a74c
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_unix.go
@@ -0,0 +1,78 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix
+
+package uv
+
+import (
+ "os"
+ "os/signal"
+ "syscall"
+
+ "github.com/charmbracelet/x/term"
+ "github.com/charmbracelet/x/termios"
+)
+
+func makeRaw(inTty, outTty term.File) (inTtyState, outTtyState *term.State, err error) {
+ if inTty == nil && outTty == nil {
+ return nil, nil, ErrNotTerminal
+ }
+
+ // Check if we have a terminal.
+ for _, f := range []term.File{inTty, outTty} {
+ if f == nil {
+ continue
+ }
+ inTtyState, err = term.MakeRaw(f.Fd())
+ if err == nil {
+ break
+ }
+ }
+
+ if err != nil {
+ return nil, nil, err //nolint:wrapcheck
+ }
+
+ return inTtyState, outTtyState, nil
+}
+
+func getWinsize(inTty, outTty term.File) (ws Winsize, err error) {
+ // Try both inTty and outTty to get the size.
+ err = ErrNotTerminal
+ for _, f := range []term.File{inTty, outTty} {
+ if f == nil {
+ continue
+ }
+ size, err := termios.GetWinsize(int(f.Fd()))
+ if err == nil {
+ return Winsize(*size), nil
+ }
+ }
+ return
+}
+
+func getSize(inTty, outTty term.File) (w, h int, err error) {
+ ws, err := getWinsize(inTty, outTty)
+ return int(ws.Col), int(ws.Row), err
+}
+
+func optimizeMovements(state *term.State) (useTabs, useBspace bool) {
+ return supportsHardTabs(uint64(state.Oflag)), supportsBackspace(uint64(state.Lflag)) //nolint:unconvert,nolintlint
+}
+
+func startWinch(inTty, outTty term.File) (c chan os.Signal, err error) {
+ for _, f := range []term.File{inTty, outTty} {
+ if f == nil {
+ continue
+ }
+ if term.IsTerminal(f.Fd()) {
+ c = make(chan os.Signal)
+ signal.Notify(c, syscall.SIGWINCH)
+ return c, nil
+ }
+ }
+ return nil, ErrNotTerminal
+}
+
+func stopWinch(c chan os.Signal) {
+ signal.Stop(c)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/terminal_windows.go b/vendor/github.com/charmbracelet/ultraviolet/terminal_windows.go
new file mode 100644
index 000000000..73a39d7bd
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/terminal_windows.go
@@ -0,0 +1,85 @@
+//go:build windows
+// +build windows
+
+package uv
+
+import (
+ "fmt"
+ "os"
+
+ "github.com/charmbracelet/x/term"
+ "golang.org/x/sys/windows"
+)
+
+func makeRaw(inTty, outTty term.File) (inTtyState, outTtyState *term.State, err error) {
+ if inTty == nil || outTty == nil || !term.IsTerminal(inTty.Fd()) || !term.IsTerminal(outTty.Fd()) {
+ return nil, nil, ErrNotTerminal
+ }
+
+ // Save stdin state and enable VT inpu
+ // We also need to enable VT input here.
+ inTtyState, err = term.MakeRaw(inTty.Fd())
+ if err != nil {
+ return nil, nil, fmt.Errorf("error making terminal raw: %w", err)
+ }
+
+ // Enable VT input
+ var imode uint32
+ if err := windows.GetConsoleMode(windows.Handle(inTty.Fd()), &imode); err != nil {
+ return nil, nil, fmt.Errorf("error getting console mode: %w", err)
+ }
+
+ if err := windows.SetConsoleMode(windows.Handle(inTty.Fd()), imode|windows.ENABLE_VIRTUAL_TERMINAL_INPUT); err != nil {
+ return nil, nil, fmt.Errorf("error setting console mode: %w", err)
+ }
+
+ // Save output screen buffer state and enable VT processing.
+ outTtyState, err = term.GetState(outTty.Fd())
+ if err != nil {
+ return nil, nil, fmt.Errorf("error getting terminal state: %w", err)
+ }
+
+ var omode uint32
+ if err := windows.GetConsoleMode(windows.Handle(outTty.Fd()), &omode); err != nil {
+ return nil, nil, fmt.Errorf("error getting console mode: %w", err)
+ }
+
+ if err := windows.SetConsoleMode(windows.Handle(outTty.Fd()),
+ omode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING|
+ windows.DISABLE_NEWLINE_AUTO_RETURN); err != nil {
+ return nil, nil, fmt.Errorf("error setting console mode: %w", err)
+ }
+
+ return inTtyState, outTtyState, nil
+}
+
+func getSize(_, outTty term.File) (w, h int, err error) {
+ if outTty != nil {
+ return term.GetSize(outTty.Fd()) //nolint:wrapcheck
+ }
+ return 0, 0, ErrNotTerminal
+}
+
+func getWinsize(inTty, outTty term.File) (ws Winsize, err error) {
+ w, h, err := getSize(inTty, outTty)
+ return Winsize{Col: uint16(w), Row: uint16(h)}, err
+}
+
+func optimizeMovements(*term.State) (useTabs, useBspace bool) {
+ return supportsBackspace(0), supportsHardTabs(0)
+}
+
+func supportsBackspace(uint64) bool {
+ return true
+}
+
+func supportsHardTabs(uint64) bool {
+ return true
+}
+
+func startWinch(_, _ term.File) (chan os.Signal, error) {
+ return nil, ErrPlatformNotSupported
+}
+
+func stopWinch(chan os.Signal) {
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/tty.go b/vendor/github.com/charmbracelet/ultraviolet/tty.go
new file mode 100644
index 000000000..7e7bd9945
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/tty.go
@@ -0,0 +1,42 @@
+package uv
+
+import (
+ "context"
+ "os"
+)
+
+// OpenTTY opens the terminal's input and output file descriptors.
+// It returns the input and output files, or an error if the terminal is not
+// available.
+//
+// This is useful for applications that need to interact with the terminal
+// directly while piping or redirecting input/output.
+func OpenTTY() (inTty, outTty *os.File, err error) {
+ return openTTY()
+}
+
+// Suspend suspends the current process group.
+func Suspend() error {
+ return suspend()
+}
+
+// NotifyWinch sets up a channel to receive window size change signals and any
+// other signals needed. This is a drop-in replacement for os/signal.Notify to
+// ensure that SIGWINCH is included.
+//
+// On Windows, this will be a no-op for SIGWINCH, but other signals may still
+// be handled.
+func NotifyWinch(c chan os.Signal, sigs ...os.Signal) {
+ notifyWinch(c, sigs...)
+}
+
+// NotifyWinchContext sets up a channel to receive window size change signals
+// and any other signals needed, with context cancellation support. This is a
+// drop-in replacement for os/signal.NotifyContext to ensure that SIGWINCH is
+// included.
+//
+// On Windows, this will be a no-op for SIGWINCH, but other signals may still
+// be handled.
+func NotifyWinchContext(ctx context.Context, sigs ...os.Signal) (context.Context, context.CancelFunc) {
+ return notifyWinchContext(ctx, sigs...)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/tty_other.go b/vendor/github.com/charmbracelet/ultraviolet/tty_other.go
new file mode 100644
index 000000000..c4c986ce9
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/tty_other.go
@@ -0,0 +1,26 @@
+//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !aix && !windows
+// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris,!aix,!windows
+
+package uv
+
+import (
+ "context"
+ "os"
+ "os/signal"
+)
+
+func openTTY() (*os.File, *os.File, error) {
+ return nil, nil, ErrPlatformNotSupported
+}
+
+func suspend() error {
+ return ErrPlatformNotSupported
+}
+
+func notifyWinch(c chan os.Signal, sigs ...os.Signal) {
+ signal.Notify(c, sigs...)
+}
+
+func notifyWinchContext(ctx context.Context, sigs ...os.Signal) (context.Context, context.CancelFunc) {
+ return signal.NotifyContext(ctx, sigs...)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/tty_unix.go b/vendor/github.com/charmbracelet/ultraviolet/tty_unix.go
new file mode 100644
index 000000000..328552cb1
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/tty_unix.go
@@ -0,0 +1,39 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || aix
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris aix
+
+package uv
+
+import (
+ "context"
+ "os"
+ "os/signal"
+ "syscall"
+
+ "golang.org/x/sys/unix"
+)
+
+func openTTY() (inTty, outTty *os.File, err error) {
+ f, err := os.OpenFile("/dev/tty", os.O_RDWR, 0)
+ if err != nil {
+ return nil, nil, err //nolint:wrapcheck
+ }
+ return f, f, nil
+}
+
+func suspend() (err error) {
+ // Send SIGTSTP to the entire process group.
+ c := make(chan os.Signal, 1)
+ signal.Notify(c, syscall.SIGCONT)
+ err = syscall.Kill(0, syscall.SIGTSTP)
+ // blocks until a CONT happens...
+ <-c
+ return
+}
+
+func notifyWinch(c chan os.Signal, sigs ...os.Signal) {
+ signal.Notify(c, append(sigs, unix.SIGWINCH)...)
+}
+
+func notifyWinchContext(ctx context.Context, sigs ...os.Signal) (context.Context, context.CancelFunc) {
+ return signal.NotifyContext(ctx, append(sigs, unix.SIGWINCH)...)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/tty_windows.go b/vendor/github.com/charmbracelet/ultraviolet/tty_windows.go
new file mode 100644
index 000000000..4ad0ecb80
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/tty_windows.go
@@ -0,0 +1,39 @@
+//go:build windows
+// +build windows
+
+package uv
+
+import (
+ "context"
+ "os"
+ "os/signal"
+)
+
+func openTTY() (inTty, outTty *os.File, err error) {
+ // On Windows, when the input/output is redirected or piped, we need to
+ // open the console explicitly.
+ // See https://learn.microsoft.com/en-us/windows/console/getstdhandle#remarks
+ inTty, err = os.OpenFile("CONIN$", os.O_RDWR, 0o644) //nolint:gosec
+ if err != nil {
+ return nil, nil, err //nolint:wrapcheck
+ }
+ outTty, err = os.OpenFile("CONOUT$", os.O_RDWR, 0o644) //nolint:gosec
+ if err != nil {
+ return nil, nil, err //nolint:wrapcheck
+ }
+ return inTty, outTty, nil
+}
+
+func suspend() (err error) {
+ // On Windows, suspending the process group is not supported in the same
+ // way as Unix-like systems.
+ return nil
+}
+
+func notifyWinch(c chan os.Signal, sigs ...os.Signal) {
+ signal.Notify(c, sigs...)
+}
+
+func notifyWinchContext(ctx context.Context, sigs ...os.Signal) (context.Context, context.CancelFunc) {
+ return signal.NotifyContext(ctx, sigs...)
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/utils.go b/vendor/github.com/charmbracelet/ultraviolet/utils.go
new file mode 100644
index 000000000..6616ebc97
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/utils.go
@@ -0,0 +1,15 @@
+package uv
+
+func abs(x int) int {
+ if x < 0 {
+ return -x
+ }
+ return x
+}
+
+func clamp(v, low, high int) int {
+ if high < low {
+ low, high = high, low
+ }
+ return min(high, max(low, v))
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/uv.go b/vendor/github.com/charmbracelet/ultraviolet/uv.go
new file mode 100644
index 000000000..546d6f332
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/uv.go
@@ -0,0 +1,359 @@
+package uv
+
+import (
+ "fmt"
+ "image/color"
+ "io"
+ "strings"
+
+ "github.com/charmbracelet/x/ansi"
+ "github.com/lucasb-eyer/go-colorful"
+)
+
+var (
+ // ErrNotTerminal is an error that indicates that the file is not a terminal.
+ ErrNotTerminal = fmt.Errorf("not a terminal")
+ // ErrPlatformNotSupported is an error that indicates that the platform is not supported.
+ ErrPlatformNotSupported = fmt.Errorf("platform not supported")
+)
+
+// Drawable represents a drawable component on a [Screen].
+type Drawable interface {
+ // Draw renders the component on the screen for the given area.
+ Draw(scr Screen, area Rectangle)
+}
+
+// DrawableFunc is a function that implements the [Drawable] interface.
+type DrawableFunc func(scr Screen, rect Rectangle)
+
+var _ Drawable = (DrawableFunc)(nil)
+
+// Draw implements the [Drawable] interface.
+func (f DrawableFunc) Draw(scr Screen, rect Rectangle) {
+ f(scr, rect)
+}
+
+// WidthMethod determines how many columns a grapheme occupies on the screen.
+type WidthMethod interface {
+ StringWidth(s string) int
+}
+
+// Screen represents a screen that can be drawn to.
+type Screen interface {
+ // Bounds returns the bounds of the screen. This is the rectangle that
+ // includes the start and end points of the screen.
+ Bounds() Rectangle
+
+ // CellAt returns the cell at the given position. If the position is out of
+ // bounds, it returns nil. Otherwise, it always returns a cell, even if it
+ // is empty (i.e., a cell with a space character and a width of 1).
+ CellAt(x, y int) *Cell
+
+ // SetCell sets the cell at the given position. A nil cell is treated as an
+ // empty cell with a space character and a width of 1.
+ SetCell(x, y int, c *Cell)
+
+ // WidthMethod returns the width method used by the screen.
+ WidthMethod() WidthMethod
+}
+
+// Cursor represents a cursor on the terminal screen.
+type Cursor struct {
+ // Position is a [Position] that determines the cursor's position on the
+ // screen relative to the top left corner of the frame.
+ Position
+
+ // Color is a [color.Color] that determines the cursor's color.
+ Color color.Color
+
+ // Shape is a [CursorShape] that determines the cursor's shape.
+ Shape CursorShape
+
+ // Blink is a boolean that determines whether the cursor should blink.
+ Blink bool
+
+ // Hidden is a boolean that determines whether the cursor is hidden. You
+ // can use this if you want to hide the cursor but still want to change its
+ // position.
+ Hidden bool
+}
+
+// NewCursor returns a new cursor with the default settings and the given
+// position.
+func NewCursor(x, y int) *Cursor {
+ return &Cursor{
+ Position: Position{X: x, Y: y},
+ Color: nil,
+ Shape: CursorBlock,
+ Blink: true,
+ }
+}
+
+// ProgressBarState represents the state of the progress bar.
+type ProgressBarState int
+
+// Progress bar states.
+const (
+ ProgressBarNone ProgressBarState = iota
+ ProgressBarDefault
+ ProgressBarError
+ ProgressBarIndeterminate
+ ProgressBarWarning
+)
+
+// String return a human-readable value for the given [ProgressBarState].
+func (s ProgressBarState) String() string {
+ return [...]string{
+ "None",
+ "Default",
+ "Error",
+ "Indeterminate",
+ "Warning",
+ }[s]
+}
+
+// ProgressBar represents the terminal progress bar.
+//
+// Support depends on the terminal.
+//
+// See https://learn.microsoft.com/en-us/windows/terminal/tutorials/progress-bar-sequences
+type ProgressBar struct {
+ // State is the current state of the progress bar. It can be one of
+ // [ProgressBarNone], [ProgressBarDefault], [ProgressBarError],
+ // [ProgressBarIndeterminate], and [ProgressBarWarning].
+ State ProgressBarState
+ // Value is the current value of the progress bar. It should be between
+ // 0 and 100.
+ Value int
+}
+
+// NewProgressBar returns a new progress bar with the given state and value.
+// The value is ignored if the state is [ProgressBarNone] or
+// [ProgressBarIndeterminate].
+func NewProgressBar(state ProgressBarState, value int) *ProgressBar {
+ return &ProgressBar{
+ State: state,
+ Value: min(max(value, 0), 100),
+ }
+}
+
+// KeyboardEnhancements defines different keyboard enhancement features that
+// can be requested from the terminal.
+type KeyboardEnhancements struct {
+ // DisambiguateEscapeCodes requests the terminal to report ambiguous keys
+ // such as Ctrl+i and Tab, and Ctrl+m and Enter, and others as distinct key
+ // code sequences.
+ // If supported, your program will receive distinct [KeyPressEvent]s for
+ // these keys.
+ DisambiguateEscapeCodes bool
+
+ // ReportEventTypes requests the terminal to report key repeat and release
+ // events.
+ // If supported, your program will receive [KeyReleaseEvent]s and
+ // [KeyPressEvent] with the [Key.IsRepeat] field set indicating that this
+ // is a it's part of a key repeat sequence.
+ ReportEventTypes bool
+}
+
+// NewKeyboardEnhancements returns a new [KeyboardEnhancements] with the given
+// options as flags.
+//
+// A zero, or negative, flags value is treated as no enhancements.
+//
+// See [ansi.KittyKeyboard] for more details on the supported keyboard enhancements.
+func NewKeyboardEnhancements(flags int) *KeyboardEnhancements {
+ if flags <= 0 {
+ return &KeyboardEnhancements{}
+ }
+
+ return &KeyboardEnhancements{
+ DisambiguateEscapeCodes: flags&ansi.KittyDisambiguateEscapeCodes != 0,
+ ReportEventTypes: flags&ansi.KittyReportEventTypes != 0,
+ }
+}
+
+// Flags returns the keyboard enhancements as bits that can be used to set the
+// appropriate terminal modes.
+func (ke KeyboardEnhancements) Flags() int {
+ bits := 0
+ if ke.DisambiguateEscapeCodes {
+ bits |= ansi.KittyDisambiguateEscapeCodes
+ }
+ if ke.ReportEventTypes {
+ bits |= ansi.KittyReportEventTypes
+ }
+
+ return bits
+}
+
+// EncodeBackgroundColor encodes the background color to the given writer. Use
+// nil to reset the background color to the default.
+func EncodeBackgroundColor(w io.Writer, c color.Color) error {
+ var seq string
+ if c == nil {
+ seq = ansi.ResetBackgroundColor
+ } else if col, ok := colorful.MakeColor(c); ok {
+ seq = ansi.SetBackgroundColor(col.Hex())
+ } else {
+ return fmt.Errorf("invalid color: %v", c)
+ }
+
+ _, err := io.WriteString(w, seq)
+ if err != nil {
+ return fmt.Errorf("failed to set background color: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeForegroundColor encodes the foreground color to the given writer. Use
+// nil to reset the foreground color to the default.
+func EncodeForegroundColor(w io.Writer, c color.Color) error {
+ var seq string
+ if c == nil {
+ seq = ansi.ResetForegroundColor
+ } else if col, ok := colorful.MakeColor(c); ok {
+ seq = ansi.SetForegroundColor(col.Hex())
+ } else {
+ return fmt.Errorf("invalid color: %v", c)
+ }
+
+ _, err := io.WriteString(w, seq)
+ if err != nil {
+ return fmt.Errorf("failed to set foreground color: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeCursorColor encodes the cursor color to the given writer. Use nil to
+// reset the cursor color to the default.
+func EncodeCursorColor(w io.Writer, c color.Color) error {
+ var seq string
+ if c == nil {
+ seq = ansi.ResetCursorColor
+ } else if col, ok := colorful.MakeColor(c); ok {
+ seq = ansi.SetCursorColor(col.Hex())
+ } else {
+ return fmt.Errorf("invalid color: %v", c)
+ }
+
+ _, err := io.WriteString(w, seq)
+ if err != nil {
+ return fmt.Errorf("failed to set cursor color: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeCursorStyle encodes the cursor style to the given writer.
+func EncodeCursorStyle(w io.Writer, shape CursorShape, blink bool) error {
+ seq := ansi.SetCursorStyle(shape.Encode(blink))
+ _, err := io.WriteString(w, seq)
+ if err != nil {
+ return fmt.Errorf("failed to set cursor style: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeBracketedPaste encodes the bracketed paste mode to the given writer.
+func EncodeBracketedPaste(w io.Writer, enable bool) error {
+ var seq string
+ if enable {
+ seq = ansi.SetModeBracketedPaste
+ } else {
+ seq = ansi.ResetModeBracketedPaste
+ }
+
+ _, err := io.WriteString(w, seq)
+ if err != nil {
+ return fmt.Errorf("failed to set bracketed paste mode: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeMouseMode encodes the mouse mode to the given writer.
+func EncodeMouseMode(w io.Writer, mode MouseMode) error {
+ var sb strings.Builder
+ switch mode {
+ case MouseModeNone:
+ sb.WriteString(ansi.ResetModeMouseNormal)
+ sb.WriteString(ansi.ResetModeMouseButtonEvent)
+ sb.WriteString(ansi.ResetModeMouseAnyEvent)
+ sb.WriteString(ansi.ResetModeMouseExtSgr)
+ case MouseModeClick:
+ sb.WriteString(ansi.SetModeMouseNormal)
+ sb.WriteString(ansi.SetModeMouseExtSgr)
+ case MouseModeDrag:
+ sb.WriteString(ansi.SetModeMouseButtonEvent)
+ sb.WriteString(ansi.SetModeMouseExtSgr)
+ case MouseModeMotion:
+ sb.WriteString(ansi.SetModeMouseAnyEvent)
+ sb.WriteString(ansi.SetModeMouseExtSgr)
+ default:
+ return fmt.Errorf("invalid mouse mode: %d", mode)
+ }
+
+ _, err := io.WriteString(w, sb.String())
+ if err != nil {
+ return fmt.Errorf("failed to set mouse mode: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeProgressBar encodes the progress bar to the given writer.
+func EncodeProgressBar(w io.Writer, pb *ProgressBar) error {
+ if pb == nil {
+ pb = &ProgressBar{State: ProgressBarNone}
+ }
+
+ var seq string
+ percent := clamp(pb.Value, 0, 100)
+ switch pb.State {
+ case ProgressBarNone:
+ seq = ansi.ResetProgressBar
+ case ProgressBarDefault:
+ seq = ansi.SetProgressBar(percent)
+ case ProgressBarError:
+ seq = ansi.SetErrorProgressBar(percent)
+ case ProgressBarIndeterminate:
+ seq = ansi.SetIndeterminateProgressBar
+ case ProgressBarWarning:
+ seq = ansi.SetWarningProgressBar(percent)
+ default:
+ return fmt.Errorf("invalid progress bar state: %d", pb.State)
+ }
+
+ _, err := io.WriteString(w, seq)
+ if err != nil {
+ return fmt.Errorf("failed to set progress bar: %w", err)
+ }
+
+ return nil
+}
+
+// EncodeKeyboardEnhancements encodes the keyboard enhancements to the given
+// writer.
+func EncodeKeyboardEnhancements(w io.Writer, ke *KeyboardEnhancements) error {
+ var flags int
+ if ke != nil {
+ flags = ke.Flags()
+ }
+ _, err := io.WriteString(w, ansi.KittyKeyboard(flags, 1))
+ if err != nil {
+ return fmt.Errorf("failed to set keyboard enhancements: %w", err)
+ }
+ return nil
+}
+
+// EncodeWindowTitle encodes the window title to the given writer.
+func EncodeWindowTitle(w io.Writer, title string) error {
+ _, err := io.WriteString(w, ansi.SetWindowTitle(title))
+ if err != nil {
+ return fmt.Errorf("failed to set window title: %w", err)
+ }
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/winch.go b/vendor/github.com/charmbracelet/ultraviolet/winch.go
new file mode 100644
index 000000000..77533f1cd
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/winch.go
@@ -0,0 +1,62 @@
+package uv
+
+import (
+ "os"
+ "sync"
+
+ "github.com/charmbracelet/x/term"
+)
+
+// SizeNotifier represents a notifier that listens for window size
+// changes using the SIGWINCH signal and notifies the given channel.
+type SizeNotifier struct {
+ // Channel that receives terminal size change notifications.
+ C <-chan os.Signal
+
+ f term.File
+ sig chan os.Signal
+ m sync.Mutex
+}
+
+// NewSizeNotifier creates a new [SizeNotifier] that listens for window size
+// changes on the given TTY file through SIGWINCH signals.
+func NewSizeNotifier(f term.File) *SizeNotifier {
+ if f == nil {
+ panic("no file set")
+ }
+ sig := make(chan os.Signal)
+ return &SizeNotifier{
+ f: f,
+ sig: sig,
+ C: sig,
+ }
+}
+
+// Start starts listening for window size changes and notifies [SizeNotifier.C]
+// about any changes.
+func (n *SizeNotifier) Start() error {
+ return n.start()
+}
+
+// Stop stops the notifier and cleans up resources.
+func (n *SizeNotifier) Stop() error {
+ return n.stop()
+}
+
+// GetWindowSize returns the current size of the terminal window.
+func (n *SizeNotifier) GetWindowSize() (cells Size, pixels Size, err error) {
+ return n.getWindowSize()
+}
+
+// GetSize returns the current cell size of the terminal window.
+func (n *SizeNotifier) GetSize() (width, height int, err error) {
+ n.m.Lock()
+ defer n.m.Unlock()
+
+ width, height, err = term.GetSize(n.f.Fd())
+ if err != nil {
+ return 0, 0, err //nolint:wrapcheck
+ }
+
+ return width, height, nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/winch_other.go b/vendor/github.com/charmbracelet/ultraviolet/winch_other.go
new file mode 100644
index 000000000..802268780
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/winch_other.go
@@ -0,0 +1,17 @@
+//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris
+// +build !darwin,!dragonfly,!freebsd,!linux,!netbsd,!openbsd,!solaris
+
+package uv
+
+func (n *SizeNotifier) start() error {
+ return ErrPlatformNotSupported
+}
+
+func (n *SizeNotifier) stop() error {
+ return ErrPlatformNotSupported
+}
+
+func (n *SizeNotifier) getWindowSize() (cells Size, pixels Size, err error) {
+ cells.Width, cells.Height, err = n.GetSize()
+ return cells, pixels, err
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/winch_unix.go b/vendor/github.com/charmbracelet/ultraviolet/winch_unix.go
new file mode 100644
index 000000000..efe0ce509
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/winch_unix.go
@@ -0,0 +1,50 @@
+//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
+// +build darwin dragonfly freebsd linux netbsd openbsd solaris zos
+
+package uv
+
+import (
+ "os/signal"
+ "syscall"
+
+ "github.com/charmbracelet/x/term"
+ "github.com/charmbracelet/x/termios"
+)
+
+func (n *SizeNotifier) start() error {
+ n.m.Lock()
+ defer n.m.Unlock()
+ if n.f == nil || !term.IsTerminal(n.f.Fd()) {
+ return ErrNotTerminal
+ }
+
+ signal.Notify(n.sig, syscall.SIGWINCH)
+ return nil
+}
+
+func (n *SizeNotifier) stop() error {
+ n.m.Lock()
+ signal.Stop(n.sig)
+ n.m.Unlock()
+ return nil
+}
+
+func (n *SizeNotifier) getWindowSize() (cells Size, pixels Size, err error) {
+ n.m.Lock()
+ defer n.m.Unlock()
+
+ winsize, err := termios.GetWinsize(int(n.f.Fd()))
+ if err != nil {
+ return Size{}, Size{}, err //nolint:wrapcheck
+ }
+
+ cells = Size{
+ Width: int(winsize.Col),
+ Height: int(winsize.Row),
+ }
+ pixels = Size{
+ Width: int(winsize.Xpixel),
+ Height: int(winsize.Ypixel),
+ }
+ return cells, pixels, nil
+}
diff --git a/vendor/github.com/charmbracelet/ultraviolet/window.go b/vendor/github.com/charmbracelet/ultraviolet/window.go
new file mode 100644
index 000000000..21c707a84
--- /dev/null
+++ b/vendor/github.com/charmbracelet/ultraviolet/window.go
@@ -0,0 +1,134 @@
+package uv
+
+import (
+ "github.com/charmbracelet/x/ansi"
+)
+
+// Window represents a rectangular area on the screen. It can be a root window
+// with no parent, or a sub-window with a parent window. A window can have its
+// own buffer or share the buffer of its parent window (view).
+type Window struct {
+ *Buffer
+
+ method *WidthMethod
+ parent *Window
+ bounds Rectangle
+}
+
+var (
+ _ Screen = (*Window)(nil)
+ _ Drawable = (*Window)(nil)
+)
+
+// HasParent returns whether the window has a parent window. This can be used
+// to determine if the window is a root window or a sub-window.
+func (w *Window) HasParent() bool {
+ return w.parent != nil
+}
+
+// Parent returns the parent window of the current window.
+// If the window does not have a parent, it returns nil.
+func (w *Window) Parent() *Window {
+ return w.parent
+}
+
+// MoveTo moves the window to the specified x and y coordinates.
+func (w *Window) MoveTo(x, y int) {
+ size := w.bounds.Size()
+ w.bounds.Min.X = x
+ w.bounds.Min.Y = y
+ w.bounds.Max.X = x + size.X
+ w.bounds.Max.Y = y + size.Y
+}
+
+// MoveBy moves the window by the specified delta x and delta y.
+func (w *Window) MoveBy(dx, dy int) {
+ w.bounds.Min.X += dx
+ w.bounds.Min.Y += dy
+ w.bounds.Max.X += dx
+ w.bounds.Max.Y += dy
+}
+
+// Clone creates an exact copy of the window, including its buffer and values.
+// The cloned window will have the same parent and method as the original
+// window.
+func (w *Window) Clone() *Window {
+ return w.CloneArea(w.Buffer.Bounds())
+}
+
+// CloneArea creates an exact copy of the window, including its buffer and
+// values, but only within the specified area. The cloned window will have the
+// same parent and method as the original window, but its bounds will be
+// limited to the specified area.
+func (w *Window) CloneArea(area Rectangle) *Window {
+ clone := new(Window)
+ clone.Buffer = w.Buffer.CloneArea(area)
+ clone.parent = w.parent
+ clone.method = w.method
+ clone.bounds = area
+ return clone
+}
+
+// Resize resizes the window to the specified width and height.
+func (w *Window) Resize(width, height int) {
+ // Only resize the buffer if this window owns its buffer.
+ if w.parent == nil || w.Buffer != w.parent.Buffer {
+ w.Buffer.Resize(width, height)
+ }
+ w.bounds.Max.X = w.bounds.Min.X + width
+ w.bounds.Max.Y = w.bounds.Min.Y + height
+}
+
+// WidthMethod returns the method used to calculate the width of characters in
+// the window.
+func (w *Window) WidthMethod() WidthMethod {
+ return *w.method
+}
+
+// Bounds returns the bounds of the window as a rectangle.
+func (w *Window) Bounds() Rectangle {
+ return w.bounds
+}
+
+// NewWindow creates a new window with its own buffer relative to the parent
+// window at the specified position and size.
+//
+// This will panic if width or height is negative.
+func (w *Window) NewWindow(x, y, width, height int) *Window {
+ return newWindow(w, x, y, width, height, w.method, false)
+}
+
+// NewView creates a new view into the parent window at the specified position
+// and size. Unlike [Window.NewWindow], this view shares the same buffer as the
+// parent window.
+func (w *Window) NewView(x, y, width, height int) *Window {
+ return newWindow(w, x, y, width, height, w.method, true)
+}
+
+// NewScreen creates a new root [Window] with the given size and width method.
+//
+// This will panic if width or height is negative.
+func NewScreen(width, height int) *Window {
+ var method WidthMethod = ansi.WcWidth
+ return newWindow(nil, 0, 0, width, height, &method, false)
+}
+
+// SetWidthMethod sets the width method for the window.
+func (w *Window) SetWidthMethod(method WidthMethod) {
+ w.method = &method
+}
+
+// newWindow creates a new [Window] with the specified parent, position,
+// method, and size.
+func newWindow(parent *Window, x, y, width, height int, method *WidthMethod, view bool) *Window {
+ w := new(Window)
+ if view {
+ w.Buffer = parent.Buffer
+ } else {
+ w.Buffer = NewBuffer(width, height)
+ }
+ w.parent = parent
+ w.method = method
+ w.bounds = Rect(x, y, width, height)
+ return w
+}
diff --git a/vendor/github.com/charmbracelet/x/ansi/kitty/decoder.go b/vendor/github.com/charmbracelet/x/ansi/kitty/decoder.go
new file mode 100644
index 000000000..7db15156e
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/ansi/kitty/decoder.go
@@ -0,0 +1,86 @@
+// Package kitty provides Kitty terminal graphics protocol functionality.
+package kitty
+
+import (
+ "compress/zlib"
+ "fmt"
+ "image"
+ "image/color"
+ "image/png"
+ "io"
+)
+
+// Decoder is a decoder for the Kitty graphics protocol. It supports decoding
+// images in the 24-bit [RGB], 32-bit [RGBA], and [PNG] formats. It can also
+// decompress data using zlib.
+// The default format is 32-bit [RGBA].
+type Decoder struct {
+ // Uses zlib decompression.
+ Decompress bool
+
+ // Can be one of [RGB], [RGBA], or [PNG].
+ Format int
+
+ // Width of the image in pixels. This can be omitted if the image is [PNG]
+ // formatted.
+ Width int
+
+ // Height of the image in pixels. This can be omitted if the image is [PNG]
+ // formatted.
+ Height int
+}
+
+// Decode decodes the image data from r in the specified format.
+func (d *Decoder) Decode(r io.Reader) (image.Image, error) {
+ if d.Decompress {
+ zr, err := zlib.NewReader(r)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create zlib reader: %w", err)
+ }
+
+ defer zr.Close() //nolint:errcheck
+ r = zr
+ }
+
+ if d.Format == 0 {
+ d.Format = RGBA
+ }
+
+ switch d.Format {
+ case RGBA, RGB:
+ return d.decodeRGBA(r, d.Format == RGBA)
+
+ case PNG:
+ return png.Decode(r) //nolint:wrapcheck
+
+ default:
+ return nil, fmt.Errorf("unsupported format: %d", d.Format)
+ }
+}
+
+// decodeRGBA decodes the image data in 32-bit RGBA or 24-bit RGB formats.
+func (d *Decoder) decodeRGBA(r io.Reader, alpha bool) (image.Image, error) {
+ m := image.NewRGBA(image.Rect(0, 0, d.Width, d.Height))
+
+ var buf []byte
+ if alpha {
+ buf = make([]byte, 4)
+ } else {
+ buf = make([]byte, 3)
+ }
+
+ for y := range d.Height {
+ for x := range d.Width {
+ if _, err := io.ReadFull(r, buf[:]); err != nil {
+ return nil, fmt.Errorf("failed to read pixel data: %w", err)
+ }
+ if alpha {
+ m.SetRGBA(x, y, color.RGBA{buf[0], buf[1], buf[2], buf[3]})
+ } else {
+ m.SetRGBA(x, y, color.RGBA{buf[0], buf[1], buf[2], 0xff})
+ }
+ }
+ }
+
+ return m, nil
+}
diff --git a/vendor/github.com/charmbracelet/x/ansi/kitty/encoder.go b/vendor/github.com/charmbracelet/x/ansi/kitty/encoder.go
new file mode 100644
index 000000000..7f7efe836
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/ansi/kitty/encoder.go
@@ -0,0 +1,64 @@
+package kitty
+
+import (
+ "compress/zlib"
+ "fmt"
+ "image"
+ "image/png"
+ "io"
+)
+
+// Encoder is an encoder for the Kitty graphics protocol. It supports encoding
+// images in the 24-bit [RGB], 32-bit [RGBA], and [PNG] formats, and
+// compressing the data using zlib.
+// The default format is 32-bit [RGBA].
+type Encoder struct {
+ // Uses zlib compression.
+ Compress bool
+
+ // Can be one of [RGBA], [RGB], or [PNG].
+ Format int
+}
+
+// Encode encodes the image data in the specified format and writes it to w.
+func (e *Encoder) Encode(w io.Writer, m image.Image) error {
+ if m == nil {
+ return nil
+ }
+
+ if e.Compress {
+ zw := zlib.NewWriter(w)
+ defer zw.Close() //nolint:errcheck
+ w = zw
+ }
+
+ if e.Format == 0 {
+ e.Format = RGBA
+ }
+
+ switch e.Format {
+ case RGBA, RGB:
+ bounds := m.Bounds()
+ for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
+ for x := bounds.Min.X; x < bounds.Max.X; x++ {
+ r, g, b, a := m.At(x, y).RGBA()
+ switch e.Format {
+ case RGBA:
+ w.Write([]byte{byte(r >> 8), byte(g >> 8), byte(b >> 8), byte(a >> 8)}) //nolint:errcheck,gosec
+ case RGB:
+ w.Write([]byte{byte(r >> 8), byte(g >> 8), byte(b >> 8)}) //nolint:errcheck,gosec
+ }
+ }
+ }
+
+ case PNG:
+ if err := png.Encode(w, m); err != nil {
+ return fmt.Errorf("failed to encode PNG: %w", err)
+ }
+
+ default:
+ return fmt.Errorf("unsupported format: %d", e.Format)
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/x/ansi/kitty/graphics.go b/vendor/github.com/charmbracelet/x/ansi/kitty/graphics.go
new file mode 100644
index 000000000..10862be87
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/ansi/kitty/graphics.go
@@ -0,0 +1,414 @@
+package kitty
+
+import "errors"
+
+// ErrMissingFile is returned when the file path is missing.
+var ErrMissingFile = errors.New("missing file path")
+
+// MaxChunkSize is the maximum chunk size for the image data.
+const MaxChunkSize = 1024 * 4
+
+// Placeholder is a special Unicode character that can be used as a placeholder
+// for an image.
+const Placeholder = '\U0010EEEE'
+
+// Graphics image format.
+const (
+ // 32-bit RGBA format.
+ RGBA = 32
+
+ // 24-bit RGB format.
+ RGB = 24
+
+ // PNG format.
+ PNG = 100
+)
+
+// Compression types.
+const (
+ Zlib = 'z'
+)
+
+// Transmission types.
+const (
+ // The data transmitted directly in the escape sequence.
+ Direct = 'd'
+
+ // The data transmitted in a regular file.
+ File = 'f'
+
+ // A temporary file is used and deleted after transmission.
+ TempFile = 't'
+
+ // A shared memory object.
+ // For POSIX see https://pubs.opengroup.org/onlinepubs/9699919799/functions/shm_open.html
+ // For Windows see https://docs.microsoft.com/en-us/windows/win32/memory/creating-named-shared-memory
+ SharedMemory = 's'
+)
+
+// Action types.
+const (
+ // Transmit image data.
+ Transmit = 't'
+ // TransmitAndPut transmit image data and display (put) it.
+ TransmitAndPut = 'T'
+ // Query terminal for image info.
+ Query = 'q'
+ // Put (display) previously transmitted image.
+ Put = 'p'
+ // Delete image.
+ Delete = 'd'
+ // Frame transmits data for animation frames.
+ Frame = 'f'
+ // Animate controls animation.
+ Animate = 'a'
+ // Compose composes animation frames.
+ Compose = 'c'
+)
+
+// Delete types.
+const (
+ // Delete all placements visible on screen.
+ DeleteAll = 'a'
+ // Delete all images with the specified id, specified using the i key. If
+ // you specify a p key for the placement id as well, then only the
+ // placement with the specified image id and placement id will be deleted.
+ DeleteID = 'i'
+ // Delete newest image with the specified number, specified using the I
+ // key. If you specify a p key for the placement id as well, then only the
+ // placement with the specified number and placement id will be deleted.
+ DeleteNumber = 'n'
+ // Delete all placements that intersect with the current cursor position.
+ DeleteCursor = 'c'
+ // Delete animation frames.
+ DeleteFrames = 'f'
+ // Delete all placements that intersect a specific cell, the cell is
+ // specified using the x and y keys.
+ DeleteCell = 'p'
+ // Delete all placements that intersect a specific cell having a specific
+ // z-index. The cell and z-index is specified using the x, y and z keys.
+ DeleteCellZ = 'q'
+ // Delete all images whose id is greater than or equal to the value of the x
+ // key and less than or equal to the value of the y.
+ DeleteRange = 'r'
+ // Delete all placements that intersect the specified column, specified using
+ // the x key.
+ DeleteColumn = 'x'
+ // Delete all placements that intersect the specified row, specified using
+ // the y key.
+ DeleteRow = 'y'
+ // Delete all placements that have the specified z-index, specified using the
+ // z key.
+ DeleteZ = 'z'
+)
+
+// Diacritic returns the diacritic rune at the specified index. If the index is
+// out of bounds, the first diacritic rune is returned.
+func Diacritic(i int) rune {
+ if i < 0 || i >= len(diacritics) {
+ return diacritics[0]
+ }
+ return diacritics[i]
+}
+
+// From https://sw.kovidgoyal.net/kitty/_downloads/f0a0de9ec8d9ff4456206db8e0814937/rowcolumn-diacritics.txt
+// See https://sw.kovidgoyal.net/kitty/graphics-protocol/#unicode-placeholders for further explanation.
+var diacritics = []rune{
+ '\u0305',
+ '\u030D',
+ '\u030E',
+ '\u0310',
+ '\u0312',
+ '\u033D',
+ '\u033E',
+ '\u033F',
+ '\u0346',
+ '\u034A',
+ '\u034B',
+ '\u034C',
+ '\u0350',
+ '\u0351',
+ '\u0352',
+ '\u0357',
+ '\u035B',
+ '\u0363',
+ '\u0364',
+ '\u0365',
+ '\u0366',
+ '\u0367',
+ '\u0368',
+ '\u0369',
+ '\u036A',
+ '\u036B',
+ '\u036C',
+ '\u036D',
+ '\u036E',
+ '\u036F',
+ '\u0483',
+ '\u0484',
+ '\u0485',
+ '\u0486',
+ '\u0487',
+ '\u0592',
+ '\u0593',
+ '\u0594',
+ '\u0595',
+ '\u0597',
+ '\u0598',
+ '\u0599',
+ '\u059C',
+ '\u059D',
+ '\u059E',
+ '\u059F',
+ '\u05A0',
+ '\u05A1',
+ '\u05A8',
+ '\u05A9',
+ '\u05AB',
+ '\u05AC',
+ '\u05AF',
+ '\u05C4',
+ '\u0610',
+ '\u0611',
+ '\u0612',
+ '\u0613',
+ '\u0614',
+ '\u0615',
+ '\u0616',
+ '\u0617',
+ '\u0657',
+ '\u0658',
+ '\u0659',
+ '\u065A',
+ '\u065B',
+ '\u065D',
+ '\u065E',
+ '\u06D6',
+ '\u06D7',
+ '\u06D8',
+ '\u06D9',
+ '\u06DA',
+ '\u06DB',
+ '\u06DC',
+ '\u06DF',
+ '\u06E0',
+ '\u06E1',
+ '\u06E2',
+ '\u06E4',
+ '\u06E7',
+ '\u06E8',
+ '\u06EB',
+ '\u06EC',
+ '\u0730',
+ '\u0732',
+ '\u0733',
+ '\u0735',
+ '\u0736',
+ '\u073A',
+ '\u073D',
+ '\u073F',
+ '\u0740',
+ '\u0741',
+ '\u0743',
+ '\u0745',
+ '\u0747',
+ '\u0749',
+ '\u074A',
+ '\u07EB',
+ '\u07EC',
+ '\u07ED',
+ '\u07EE',
+ '\u07EF',
+ '\u07F0',
+ '\u07F1',
+ '\u07F3',
+ '\u0816',
+ '\u0817',
+ '\u0818',
+ '\u0819',
+ '\u081B',
+ '\u081C',
+ '\u081D',
+ '\u081E',
+ '\u081F',
+ '\u0820',
+ '\u0821',
+ '\u0822',
+ '\u0823',
+ '\u0825',
+ '\u0826',
+ '\u0827',
+ '\u0829',
+ '\u082A',
+ '\u082B',
+ '\u082C',
+ '\u082D',
+ '\u0951',
+ '\u0953',
+ '\u0954',
+ '\u0F82',
+ '\u0F83',
+ '\u0F86',
+ '\u0F87',
+ '\u135D',
+ '\u135E',
+ '\u135F',
+ '\u17DD',
+ '\u193A',
+ '\u1A17',
+ '\u1A75',
+ '\u1A76',
+ '\u1A77',
+ '\u1A78',
+ '\u1A79',
+ '\u1A7A',
+ '\u1A7B',
+ '\u1A7C',
+ '\u1B6B',
+ '\u1B6D',
+ '\u1B6E',
+ '\u1B6F',
+ '\u1B70',
+ '\u1B71',
+ '\u1B72',
+ '\u1B73',
+ '\u1CD0',
+ '\u1CD1',
+ '\u1CD2',
+ '\u1CDA',
+ '\u1CDB',
+ '\u1CE0',
+ '\u1DC0',
+ '\u1DC1',
+ '\u1DC3',
+ '\u1DC4',
+ '\u1DC5',
+ '\u1DC6',
+ '\u1DC7',
+ '\u1DC8',
+ '\u1DC9',
+ '\u1DCB',
+ '\u1DCC',
+ '\u1DD1',
+ '\u1DD2',
+ '\u1DD3',
+ '\u1DD4',
+ '\u1DD5',
+ '\u1DD6',
+ '\u1DD7',
+ '\u1DD8',
+ '\u1DD9',
+ '\u1DDA',
+ '\u1DDB',
+ '\u1DDC',
+ '\u1DDD',
+ '\u1DDE',
+ '\u1DDF',
+ '\u1DE0',
+ '\u1DE1',
+ '\u1DE2',
+ '\u1DE3',
+ '\u1DE4',
+ '\u1DE5',
+ '\u1DE6',
+ '\u1DFE',
+ '\u20D0',
+ '\u20D1',
+ '\u20D4',
+ '\u20D5',
+ '\u20D6',
+ '\u20D7',
+ '\u20DB',
+ '\u20DC',
+ '\u20E1',
+ '\u20E7',
+ '\u20E9',
+ '\u20F0',
+ '\u2CEF',
+ '\u2CF0',
+ '\u2CF1',
+ '\u2DE0',
+ '\u2DE1',
+ '\u2DE2',
+ '\u2DE3',
+ '\u2DE4',
+ '\u2DE5',
+ '\u2DE6',
+ '\u2DE7',
+ '\u2DE8',
+ '\u2DE9',
+ '\u2DEA',
+ '\u2DEB',
+ '\u2DEC',
+ '\u2DED',
+ '\u2DEE',
+ '\u2DEF',
+ '\u2DF0',
+ '\u2DF1',
+ '\u2DF2',
+ '\u2DF3',
+ '\u2DF4',
+ '\u2DF5',
+ '\u2DF6',
+ '\u2DF7',
+ '\u2DF8',
+ '\u2DF9',
+ '\u2DFA',
+ '\u2DFB',
+ '\u2DFC',
+ '\u2DFD',
+ '\u2DFE',
+ '\u2DFF',
+ '\uA66F',
+ '\uA67C',
+ '\uA67D',
+ '\uA6F0',
+ '\uA6F1',
+ '\uA8E0',
+ '\uA8E1',
+ '\uA8E2',
+ '\uA8E3',
+ '\uA8E4',
+ '\uA8E5',
+ '\uA8E6',
+ '\uA8E7',
+ '\uA8E8',
+ '\uA8E9',
+ '\uA8EA',
+ '\uA8EB',
+ '\uA8EC',
+ '\uA8ED',
+ '\uA8EE',
+ '\uA8EF',
+ '\uA8F0',
+ '\uA8F1',
+ '\uAAB0',
+ '\uAAB2',
+ '\uAAB3',
+ '\uAAB7',
+ '\uAAB8',
+ '\uAABE',
+ '\uAABF',
+ '\uAAC1',
+ '\uFE20',
+ '\uFE21',
+ '\uFE22',
+ '\uFE23',
+ '\uFE24',
+ '\uFE25',
+ '\uFE26',
+ '\U00010A0F',
+ '\U00010A38',
+ '\U0001D185',
+ '\U0001D186',
+ '\U0001D187',
+ '\U0001D188',
+ '\U0001D189',
+ '\U0001D1AA',
+ '\U0001D1AB',
+ '\U0001D1AC',
+ '\U0001D1AD',
+ '\U0001D242',
+ '\U0001D243',
+ '\U0001D244',
+}
diff --git a/vendor/github.com/charmbracelet/x/ansi/kitty/options.go b/vendor/github.com/charmbracelet/x/ansi/kitty/options.go
new file mode 100644
index 000000000..1ddfcdbb1
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/ansi/kitty/options.go
@@ -0,0 +1,373 @@
+package kitty
+
+import (
+ "encoding"
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+var (
+ _ encoding.TextMarshaler = Options{}
+ _ encoding.TextUnmarshaler = &Options{}
+)
+
+type Stringish interface{ string | []byte }
+
+// Options represents a Kitty Graphics Protocol options.
+type Options struct {
+ // Common options.
+
+ // Action (a=t) is the action to be performed on the image. Can be one of
+ // [Transmit], [TransmitDisplay], [Query], [Put], [Delete], [Frame],
+ // [Animate], [Compose].
+ Action byte
+
+ // Quite mode (q=0) is the quiet mode. Can be either zero, one, or two
+ // where zero is the default, 1 suppresses OK responses, and 2 suppresses
+ // both OK and error responses.
+ Quite byte
+
+ // Transmission options.
+
+ // ID (i=) is the image ID. The ID is a unique identifier for the image.
+ // Must be a positive integer up to [math.MaxUint32].
+ ID int
+
+ // PlacementID (p=) is the placement ID. The placement ID is a unique
+ // identifier for the placement of the image. Must be a positive integer up
+ // to [math.MaxUint32].
+ PlacementID int
+
+ // Number (I=0) is the number of images to be transmitted.
+ Number int
+
+ // Format (f=32) is the image format. One of [RGBA], [RGB], [PNG].
+ Format int
+
+ // ImageWidth (s=0) is the transmitted image width.
+ ImageWidth int
+
+ // ImageHeight (v=0) is the transmitted image height.
+ ImageHeight int
+
+ // Compression (o=) is the image compression type. Can be [Zlib] or zero.
+ Compression byte
+
+ // Transmission (t=d) is the image transmission type. Can be [Direct], [File],
+ // [TempFile], or[SharedMemory].
+ Transmission byte
+
+ // File is the file path to be used when the transmission type is [File].
+ // If [Options.Transmission] is omitted i.e. zero and this is non-empty,
+ // the transmission type is set to [File].
+ File string
+
+ // Size (S=0) is the size to be read from the transmission medium.
+ Size int
+
+ // Offset (O=0) is the offset byte to start reading from the transmission
+ // medium.
+ Offset int
+
+ // Chunk (m=) whether the image is transmitted in chunks. Can be either
+ // zero or one. When true, the image is transmitted in chunks. Each chunk
+ // must be a multiple of 4, and up to [MaxChunkSize] bytes. Each chunk must
+ // have the m=1 option except for the last chunk which must have m=0.
+ Chunk bool
+
+ // ChunkFormatter is the function used to format each chunk when
+ // [Options.Chunk] is true. If nil, the chunks are sent as is.
+ ChunkFormatter func(chunk string) string
+
+ // Display options.
+
+ // X (x=0) is the pixel X coordinate of the image to start displaying.
+ X int
+
+ // Y (y=0) is the pixel Y coordinate of the image to start displaying.
+ Y int
+
+ // Z (z=0) is the Z coordinate of the image to display.
+ Z int
+
+ // Width (w=0) is the width of the image to display.
+ Width int
+
+ // Height (h=0) is the height of the image to display.
+ Height int
+
+ // OffsetX (X=0) is the OffsetX coordinate of the cursor cell to start
+ // displaying the image. OffsetX=0 is the leftmost cell. This must be
+ // smaller than the terminal cell width.
+ OffsetX int
+
+ // OffsetY (Y=0) is the OffsetY coordinate of the cursor cell to start
+ // displaying the image. OffsetY=0 is the topmost cell. This must be
+ // smaller than the terminal cell height.
+ OffsetY int
+
+ // Columns (c=0) is the number of columns to display the image. The image
+ // will be scaled to fit the number of columns.
+ Columns int
+
+ // Rows (r=0) is the number of rows to display the image. The image will be
+ // scaled to fit the number of rows.
+ Rows int
+
+ // VirtualPlacement (U=0) whether to use virtual placement. This is used
+ // with Unicode [Placeholder] to display images.
+ VirtualPlacement bool
+
+ // DoNotMoveCursor (C=0) whether to move the cursor after displaying the
+ // image.
+ DoNotMoveCursor bool
+
+ // ParentID (P=0) is the parent image ID. The parent ID is the ID of the
+ // image that is the parent of the current image. This is used with Unicode
+ // [Placeholder] to display images relative to the parent image.
+ ParentID int
+
+ // ParentPlacementID (Q=0) is the parent placement ID. The parent placement
+ // ID is the ID of the placement of the parent image. This is used with
+ // Unicode [Placeholder] to display images relative to the parent image.
+ ParentPlacementID int
+
+ // Delete options.
+
+ // Delete (d=a) is the delete action. Can be one of [DeleteAll],
+ // [DeleteID], [DeleteNumber], [DeleteCursor], [DeleteFrames],
+ // [DeleteCell], [DeleteCellZ], [DeleteRange], [DeleteColumn], [DeleteRow],
+ // [DeleteZ].
+ Delete byte
+
+ // DeleteResources indicates whether to delete the resources associated
+ // with the image.
+ DeleteResources bool
+}
+
+// Options returns the options as a slice of a key-value pairs.
+func (o *Options) Options() (opts []string) {
+ opts = []string{}
+ if o.Format == 0 {
+ o.Format = RGBA
+ }
+
+ if o.Action == 0 {
+ o.Action = Transmit
+ }
+
+ if o.Delete == 0 {
+ o.Delete = DeleteAll
+ }
+
+ if o.Transmission == 0 {
+ if len(o.File) > 0 {
+ o.Transmission = File
+ } else {
+ o.Transmission = Direct
+ }
+ }
+
+ if o.Format != RGBA {
+ opts = append(opts, fmt.Sprintf("f=%d", o.Format))
+ }
+
+ if o.Quite > 0 {
+ opts = append(opts, fmt.Sprintf("q=%d", o.Quite))
+ }
+
+ if o.ID > 0 {
+ opts = append(opts, fmt.Sprintf("i=%d", o.ID))
+ }
+
+ if o.PlacementID > 0 {
+ opts = append(opts, fmt.Sprintf("p=%d", o.PlacementID))
+ }
+
+ if o.Number > 0 {
+ opts = append(opts, fmt.Sprintf("I=%d", o.Number))
+ }
+
+ if o.ImageWidth > 0 {
+ opts = append(opts, fmt.Sprintf("s=%d", o.ImageWidth))
+ }
+
+ if o.ImageHeight > 0 {
+ opts = append(opts, fmt.Sprintf("v=%d", o.ImageHeight))
+ }
+
+ if o.Transmission != Direct {
+ opts = append(opts, fmt.Sprintf("t=%c", o.Transmission))
+ }
+
+ if o.Size > 0 {
+ opts = append(opts, fmt.Sprintf("S=%d", o.Size))
+ }
+
+ if o.Offset > 0 {
+ opts = append(opts, fmt.Sprintf("O=%d", o.Offset))
+ }
+
+ if o.Compression == Zlib {
+ opts = append(opts, fmt.Sprintf("o=%c", o.Compression))
+ }
+
+ if o.VirtualPlacement {
+ opts = append(opts, "U=1")
+ }
+
+ if o.DoNotMoveCursor {
+ opts = append(opts, "C=1")
+ }
+
+ if o.ParentID > 0 {
+ opts = append(opts, fmt.Sprintf("P=%d", o.ParentID))
+ }
+
+ if o.ParentPlacementID > 0 {
+ opts = append(opts, fmt.Sprintf("Q=%d", o.ParentPlacementID))
+ }
+
+ if o.X > 0 {
+ opts = append(opts, fmt.Sprintf("x=%d", o.X))
+ }
+
+ if o.Y > 0 {
+ opts = append(opts, fmt.Sprintf("y=%d", o.Y))
+ }
+
+ if o.Z > 0 {
+ opts = append(opts, fmt.Sprintf("z=%d", o.Z))
+ }
+
+ if o.Width > 0 {
+ opts = append(opts, fmt.Sprintf("w=%d", o.Width))
+ }
+
+ if o.Height > 0 {
+ opts = append(opts, fmt.Sprintf("h=%d", o.Height))
+ }
+
+ if o.OffsetX > 0 {
+ opts = append(opts, fmt.Sprintf("X=%d", o.OffsetX))
+ }
+
+ if o.OffsetY > 0 {
+ opts = append(opts, fmt.Sprintf("Y=%d", o.OffsetY))
+ }
+
+ if o.Columns > 0 {
+ opts = append(opts, fmt.Sprintf("c=%d", o.Columns))
+ }
+
+ if o.Rows > 0 {
+ opts = append(opts, fmt.Sprintf("r=%d", o.Rows))
+ }
+
+ if o.Delete != DeleteAll || o.DeleteResources {
+ da := o.Delete
+ if o.DeleteResources {
+ da = da - ' ' // to uppercase
+ }
+
+ opts = append(opts, fmt.Sprintf("d=%c", da))
+ }
+
+ if o.Action != Transmit {
+ opts = append(opts, fmt.Sprintf("a=%c", o.Action))
+ }
+
+ return opts // complex function with multiple returns
+}
+
+// String returns the string representation of the options.
+func (o Options) String() string {
+ return strings.Join(o.Options(), ",")
+}
+
+// MarshalText returns the string representation of the options.
+func (o Options) MarshalText() ([]byte, error) {
+ return []byte(o.String()), nil
+}
+
+// UnmarshalText parses the options from the given string.
+func (o *Options) UnmarshalText(text []byte) error {
+ opts := strings.Split(string(text), ",")
+ for _, opt := range opts {
+ ps := strings.SplitN(opt, "=", 2)
+ if len(ps) != 2 || len(ps[1]) == 0 {
+ continue
+ }
+
+ switch ps[0] {
+ case "a":
+ o.Action = ps[1][0]
+ case "o":
+ o.Compression = ps[1][0]
+ case "t":
+ o.Transmission = ps[1][0]
+ case "d":
+ d := ps[1][0]
+ if d >= 'A' && d <= 'Z' {
+ o.DeleteResources = true
+ d = d + ' ' // to lowercase
+ }
+ o.Delete = d
+ case "i", "q", "p", "I", "f", "s", "v", "S", "O", "m", "x", "y", "z", "w", "h", "X", "Y", "c", "r", "U", "P", "Q":
+ v, err := strconv.Atoi(ps[1])
+ if err != nil {
+ continue
+ }
+
+ switch ps[0] {
+ case "i":
+ o.ID = v
+ case "q":
+ o.Quite = byte(v)
+ case "p":
+ o.PlacementID = v
+ case "I":
+ o.Number = v
+ case "f":
+ o.Format = v
+ case "s":
+ o.ImageWidth = v
+ case "v":
+ o.ImageHeight = v
+ case "S":
+ o.Size = v
+ case "O":
+ o.Offset = v
+ case "m":
+ o.Chunk = v == 0 || v == 1
+ case "x":
+ o.X = v
+ case "y":
+ o.Y = v
+ case "z":
+ o.Z = v
+ case "w":
+ o.Width = v
+ case "h":
+ o.Height = v
+ case "X":
+ o.OffsetX = v
+ case "Y":
+ o.OffsetY = v
+ case "c":
+ o.Columns = v
+ case "r":
+ o.Rows = v
+ case "U":
+ o.VirtualPlacement = v == 1
+ case "P":
+ o.ParentID = v
+ case "Q":
+ o.ParentPlacementID = v
+ }
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/charmbracelet/x/ansi/kitty/writer.go b/vendor/github.com/charmbracelet/x/ansi/kitty/writer.go
new file mode 100644
index 000000000..90f822d16
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/ansi/kitty/writer.go
@@ -0,0 +1,187 @@
+package kitty
+
+import (
+ "bytes"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "image"
+ "io"
+ "os"
+
+ "github.com/charmbracelet/x/ansi"
+)
+
+var (
+ // GraphicsTempDir is the directory where temporary files are stored.
+ // This is used in [WriteKittyGraphics] along with [os.CreateTemp].
+ GraphicsTempDir = ""
+
+ // GraphicsTempPattern is the pattern used to create temporary files.
+ // This is used in [WriteKittyGraphics] along with [os.CreateTemp].
+ // The Kitty Graphics protocol requires the file path to contain the
+ // substring "tty-graphics-protocol".
+ GraphicsTempPattern = "tty-graphics-protocol-*"
+)
+
+// EncodeGraphics writes an image using the Kitty Graphics protocol with the
+// given options to w. It chunks the written data if o.Chunk is true.
+//
+// You can omit m and use nil when rendering an image from a file. In this
+// case, you must provide a file path in o.File and use o.Transmission =
+// [File]. You can also use o.Transmission = [TempFile] to write
+// the image to a temporary file. In that case, the file path is ignored, and
+// the image is written to a temporary file that is automatically deleted by
+// the terminal.
+//
+// See https://sw.kovidgoyal.net/kitty/graphics-protocol/
+func EncodeGraphics(w io.Writer, m image.Image, o *Options) error {
+ if o == nil {
+ o = &Options{}
+ }
+
+ if o.Transmission == 0 && len(o.File) != 0 {
+ o.Transmission = File
+ }
+
+ var data bytes.Buffer // the data to be encoded into base64
+ e := &Encoder{
+ Compress: o.Compression == Zlib,
+ Format: o.Format,
+ }
+
+ switch o.Transmission {
+ case Direct:
+ if err := e.Encode(&data, m); err != nil {
+ return fmt.Errorf("failed to encode direct image: %w", err)
+ }
+
+ case SharedMemory:
+ //nolint:godox
+ // TODO: Implement shared memory
+ return fmt.Errorf("shared memory transmission is not yet implemented")
+
+ case File:
+ if len(o.File) == 0 {
+ return ErrMissingFile
+ }
+
+ f, err := os.Open(o.File)
+ if err != nil {
+ return fmt.Errorf("failed to open file: %w", err)
+ }
+
+ defer f.Close() //nolint:errcheck
+
+ stat, err := f.Stat()
+ if err != nil {
+ return fmt.Errorf("failed to get file info: %w", err)
+ }
+
+ mode := stat.Mode()
+ if !mode.IsRegular() {
+ return fmt.Errorf("file is not a regular file")
+ }
+
+ // Write the file path to the buffer
+ if _, err := data.WriteString(f.Name()); err != nil {
+ return fmt.Errorf("failed to write file path to buffer: %w", err)
+ }
+
+ case TempFile:
+ f, err := os.CreateTemp(GraphicsTempDir, GraphicsTempPattern)
+ if err != nil {
+ return fmt.Errorf("failed to create file: %w", err)
+ }
+
+ defer f.Close() //nolint:errcheck
+
+ if err := e.Encode(f, m); err != nil {
+ return fmt.Errorf("failed to encode image to file: %w", err)
+ }
+
+ // Write the file path to the buffer
+ if _, err := data.WriteString(f.Name()); err != nil {
+ return fmt.Errorf("failed to write file path to buffer: %w", err)
+ }
+ }
+
+ // Encode image to base64
+ var payload bytes.Buffer // the base64 encoded image to be written to w
+ b64 := base64.NewEncoder(base64.StdEncoding, &payload)
+ if _, err := data.WriteTo(b64); err != nil {
+ return fmt.Errorf("failed to write base64 encoded image to payload: %w", err)
+ }
+ if err := b64.Close(); err != nil {
+ return err //nolint:wrapcheck
+ }
+
+ // If not chunking, write all at once
+ if !o.Chunk {
+ _, err := io.WriteString(w, ansi.KittyGraphics(payload.Bytes(), o.Options()...))
+ return err //nolint:wrapcheck
+ }
+
+ // Write in chunks
+ var (
+ err error
+ n int
+ )
+ chunk := make([]byte, MaxChunkSize)
+ isFirstChunk := true
+ chunkFormatter := o.ChunkFormatter
+ if chunkFormatter == nil {
+ // Default to no formatting
+ chunkFormatter = func(s string) string { return s }
+ }
+
+ for {
+ // Stop if we read less than the chunk size [MaxChunkSize].
+ n, err = io.ReadFull(&payload, chunk)
+ if errors.Is(err, io.ErrUnexpectedEOF) || errors.Is(err, io.EOF) {
+ break
+ }
+ if err != nil {
+ return fmt.Errorf("failed to read chunk: %w", err)
+ }
+
+ opts := buildChunkOptions(o, isFirstChunk, false)
+ if _, err := io.WriteString(w,
+ chunkFormatter(ansi.KittyGraphics(chunk[:n], opts...))); err != nil {
+ return err //nolint:wrapcheck
+ }
+
+ isFirstChunk = false
+ }
+
+ // Write the last chunk
+ opts := buildChunkOptions(o, isFirstChunk, true)
+ _, err = io.WriteString(w, chunkFormatter(ansi.KittyGraphics(chunk[:n], opts...)))
+ return err //nolint:wrapcheck
+}
+
+// buildChunkOptions creates the options slice for a chunk.
+func buildChunkOptions(o *Options, isFirstChunk, isLastChunk bool) []string {
+ var opts []string
+ if isFirstChunk {
+ opts = o.Options()
+ } else {
+ // These options are allowed in subsequent chunks
+ if o.Quite > 0 {
+ opts = append(opts, fmt.Sprintf("q=%d", o.Quite))
+ }
+ if o.Action == Frame {
+ opts = append(opts, "a=f")
+ }
+ }
+
+ if !isFirstChunk || !isLastChunk {
+ // We don't need to encode the (m=) option when we only have one chunk.
+ if isLastChunk {
+ opts = append(opts, "m=0")
+ } else {
+ opts = append(opts, "m=1")
+ }
+ }
+ return opts
+}
diff --git a/vendor/github.com/charmbracelet/x/termios/LICENSE b/vendor/github.com/charmbracelet/x/termios/LICENSE
new file mode 100644
index 000000000..65a5654e2
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Charmbracelet, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/charmbracelet/x/termios/bit_bsd.go b/vendor/github.com/charmbracelet/x/termios/bit_bsd.go
new file mode 100644
index 000000000..8dc1eeddf
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/bit_bsd.go
@@ -0,0 +1,7 @@
+//go:build netbsd || openbsd
+// +build netbsd openbsd
+
+package termios
+
+func speed(b uint32) int32 { return int32(b) }
+func bit(b uint32) uint32 { return b }
diff --git a/vendor/github.com/charmbracelet/x/termios/bit_darwin.go b/vendor/github.com/charmbracelet/x/termios/bit_darwin.go
new file mode 100644
index 000000000..de5d5c4bb
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/bit_darwin.go
@@ -0,0 +1,7 @@
+//go:build darwin
+// +build darwin
+
+package termios
+
+func speed(b uint32) uint64 { return uint64(b) }
+func bit(b uint32) uint64 { return uint64(b) }
diff --git a/vendor/github.com/charmbracelet/x/termios/bit_other.go b/vendor/github.com/charmbracelet/x/termios/bit_other.go
new file mode 100644
index 000000000..afdf58fd9
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/bit_other.go
@@ -0,0 +1,7 @@
+//go:build !darwin && !netbsd && !openbsd
+// +build !darwin,!netbsd,!openbsd
+
+package termios
+
+func speed(b uint32) uint32 { return b }
+func bit(b uint32) uint32 { return b }
diff --git a/vendor/github.com/charmbracelet/x/termios/syscalls_bsd.go b/vendor/github.com/charmbracelet/x/termios/syscalls_bsd.go
new file mode 100644
index 000000000..8ee014bd6
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/syscalls_bsd.go
@@ -0,0 +1,11 @@
+//go:build darwin && netbsd && freebsd && netbsd
+// +build darwin,netbsd,freebsd,netbsd
+
+package term
+
+import "syscall"
+
+func init() {
+ allCcOpts[STATUS] = syscall.VSTATUS
+ allCcOpts[DSUSP] = syscall.VDSUSP
+}
diff --git a/vendor/github.com/charmbracelet/x/termios/syscalls_darwin.go b/vendor/github.com/charmbracelet/x/termios/syscalls_darwin.go
new file mode 100644
index 000000000..560c8a2b0
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/syscalls_darwin.go
@@ -0,0 +1,10 @@
+//go:build darwin
+// +build darwin
+
+package termios
+
+import "syscall"
+
+func init() {
+ allLineOpts[IUTF8] = syscall.IUTF8
+}
diff --git a/vendor/github.com/charmbracelet/x/termios/syscalls_linux.go b/vendor/github.com/charmbracelet/x/termios/syscalls_linux.go
new file mode 100644
index 000000000..7aee0ae77
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/syscalls_linux.go
@@ -0,0 +1,14 @@
+//go:build linux
+// +build linux
+
+package termios
+
+import "syscall"
+
+func init() {
+ allCcOpts[SWTCH] = syscall.VSWTC
+ allInputOpts[IUCLC] = syscall.IUCLC
+ allLineOpts[IUTF8] = syscall.IUTF8
+ allLineOpts[XCASE] = syscall.XCASE
+ allOutputOpts[OLCUC] = syscall.OLCUC
+}
diff --git a/vendor/github.com/charmbracelet/x/termios/termios.go b/vendor/github.com/charmbracelet/x/termios/termios.go
new file mode 100644
index 000000000..07cdacf22
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/termios.go
@@ -0,0 +1,249 @@
+//go:build darwin || netbsd || freebsd || openbsd || linux || dragonfly || solaris
+// +build darwin netbsd freebsd openbsd linux dragonfly solaris
+
+package termios
+
+import (
+ "syscall"
+
+ "golang.org/x/sys/unix"
+)
+
+// SetWinsize sets window size for an fd from a Winsize.
+func SetWinsize(fd int, w *unix.Winsize) error {
+ return unix.IoctlSetWinsize(fd, ioctlSetWinSize, w)
+}
+
+// GetWinsize gets window size for an fd.
+func GetWinsize(fd int) (*unix.Winsize, error) {
+ return unix.IoctlGetWinsize(fd, ioctlGetWinSize)
+}
+
+// GetTermios gets the termios of the given fd.
+func GetTermios(fd int) (*unix.Termios, error) {
+ return unix.IoctlGetTermios(fd, ioctlGets)
+}
+
+// SetTermios sets the given termios over the given fd's current termios.
+func SetTermios(
+ fd int,
+ ispeed uint32,
+ ospeed uint32,
+ cc map[CC]uint8,
+ iflag map[I]bool,
+ oflag map[O]bool,
+ cflag map[C]bool,
+ lflag map[L]bool,
+) error {
+ term, err := unix.IoctlGetTermios(fd, ioctlGets)
+ if err != nil {
+ return err
+ }
+ setSpeed(term, ispeed, ospeed)
+
+ for key, value := range cc {
+ call, ok := allCcOpts[key]
+ if !ok {
+ continue
+ }
+ term.Cc[call] = value
+ }
+
+ for key, value := range iflag {
+ mask, ok := allInputOpts[key]
+ if ok {
+ if value {
+ term.Iflag |= bit(mask)
+ } else {
+ term.Iflag &= ^bit(mask)
+ }
+ }
+ }
+ for key, value := range oflag {
+ mask, ok := allOutputOpts[key]
+ if ok {
+ if value {
+ term.Oflag |= bit(mask)
+ } else {
+ term.Oflag &= ^bit(mask)
+ }
+ }
+ }
+ for key, value := range cflag {
+ mask, ok := allControlOpts[key]
+ if ok {
+ if value {
+ term.Cflag |= bit(mask)
+ } else {
+ term.Cflag &= ^bit(mask)
+ }
+ }
+ }
+ for key, value := range lflag {
+ mask, ok := allLineOpts[key]
+ if ok {
+ if value {
+ term.Lflag |= bit(mask)
+ } else {
+ term.Lflag &= ^bit(mask)
+ }
+ }
+ }
+ return unix.IoctlSetTermios(fd, ioctlSets, term)
+}
+
+// CC is the termios cc field.
+//
+// It stores an array of special characters related to terminal I/O.
+type CC uint8
+
+// CC possible values.
+const (
+ INTR CC = iota
+ QUIT
+ ERASE
+ KILL
+ EOF
+ EOL
+ EOL2
+ START
+ STOP
+ SUSP
+ WERASE
+ RPRNT
+ LNEXT
+ DISCARD
+ STATUS
+ SWTCH
+ DSUSP
+ FLUSH
+)
+
+// https://www.man7.org/linux/man-pages/man3/termios.3.html
+var allCcOpts = map[CC]int{
+ INTR: syscall.VINTR,
+ QUIT: syscall.VQUIT,
+ ERASE: syscall.VERASE,
+ KILL: syscall.VQUIT,
+ EOF: syscall.VEOF,
+ EOL: syscall.VEOL,
+ EOL2: syscall.VEOL2,
+ START: syscall.VSTART,
+ STOP: syscall.VSTOP,
+ SUSP: syscall.VSUSP,
+ WERASE: syscall.VWERASE,
+ RPRNT: syscall.VREPRINT,
+ LNEXT: syscall.VLNEXT,
+ DISCARD: syscall.VDISCARD,
+
+ // XXX: these syscalls don't exist for any OS
+ // FLUSH: syscall.VFLUSH,
+}
+
+// Input Controls
+type I uint8
+
+// Input possible values.
+const (
+ IGNPAR I = iota
+ PARMRK
+ INPCK
+ ISTRIP
+ INLCR
+ IGNCR
+ ICRNL
+ IXON
+ IXANY
+ IXOFF
+ IMAXBEL
+ IUCLC
+)
+
+var allInputOpts = map[I]uint32{
+ IGNPAR: syscall.IGNPAR,
+ PARMRK: syscall.PARMRK,
+ INPCK: syscall.INPCK,
+ ISTRIP: syscall.ISTRIP,
+ INLCR: syscall.INLCR,
+ IGNCR: syscall.IGNCR,
+ ICRNL: syscall.ICRNL,
+ IXON: syscall.IXON,
+ IXANY: syscall.IXANY,
+ IXOFF: syscall.IXOFF,
+ IMAXBEL: syscall.IMAXBEL,
+}
+
+// Output Controls
+type O uint8
+
+// Output possible values.
+const (
+ OPOST O = iota
+ ONLCR
+ OCRNL
+ ONOCR
+ ONLRET
+ OLCUC
+)
+
+var allOutputOpts = map[O]uint32{
+ OPOST: syscall.OPOST,
+ ONLCR: syscall.ONLCR,
+ OCRNL: syscall.OCRNL,
+ ONOCR: syscall.ONOCR,
+ ONLRET: syscall.ONLRET,
+}
+
+// Control
+type C uint8
+
+// Control possible values.
+const (
+ CS7 C = iota
+ CS8
+ PARENB
+ PARODD
+)
+
+var allControlOpts = map[C]uint32{
+ CS7: syscall.CS7,
+ CS8: syscall.CS8,
+ PARENB: syscall.PARENB,
+ PARODD: syscall.PARODD,
+}
+
+// Line Controls.
+type L uint8
+
+// Line possible values.
+const (
+ ISIG L = iota
+ ICANON
+ ECHO
+ ECHOE
+ ECHOK
+ ECHONL
+ NOFLSH
+ TOSTOP
+ IEXTEN
+ ECHOCTL
+ ECHOKE
+ PENDIN
+ IUTF8
+ XCASE
+)
+
+var allLineOpts = map[L]uint32{
+ ISIG: syscall.ISIG,
+ ICANON: syscall.ICANON,
+ ECHO: syscall.ECHO,
+ ECHOE: syscall.ECHOE,
+ ECHOK: syscall.ECHOK,
+ ECHONL: syscall.ECHONL,
+ NOFLSH: syscall.NOFLSH,
+ TOSTOP: syscall.TOSTOP,
+ IEXTEN: syscall.IEXTEN,
+ ECHOCTL: syscall.ECHOCTL,
+ ECHOKE: syscall.ECHOKE,
+ PENDIN: syscall.PENDIN,
+}
diff --git a/vendor/github.com/charmbracelet/x/termios/termios_bsd.go b/vendor/github.com/charmbracelet/x/termios/termios_bsd.go
new file mode 100644
index 000000000..ef62f1975
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/termios_bsd.go
@@ -0,0 +1,13 @@
+//go:build darwin || netbsd || freebsd || openbsd || dragonfly
+// +build darwin netbsd freebsd openbsd dragonfly
+
+package termios
+
+import "golang.org/x/sys/unix"
+
+const (
+ ioctlGets = unix.TIOCGETA
+ ioctlSets = unix.TIOCSETA
+ ioctlGetWinSize = unix.TIOCGWINSZ
+ ioctlSetWinSize = unix.TIOCSWINSZ
+)
diff --git a/vendor/github.com/charmbracelet/x/termios/termios_linux.go b/vendor/github.com/charmbracelet/x/termios/termios_linux.go
new file mode 100644
index 000000000..c78557588
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/termios_linux.go
@@ -0,0 +1,13 @@
+//go:build linux
+// +build linux
+
+package termios
+
+import "golang.org/x/sys/unix"
+
+const (
+ ioctlGets = unix.TCGETS
+ ioctlSets = unix.TCSETS
+ ioctlGetWinSize = unix.TIOCGWINSZ
+ ioctlSetWinSize = unix.TIOCSWINSZ
+)
diff --git a/vendor/github.com/charmbracelet/x/termios/termios_other.go b/vendor/github.com/charmbracelet/x/termios/termios_other.go
new file mode 100644
index 000000000..129dfcee9
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/termios_other.go
@@ -0,0 +1,15 @@
+//go:build darwin || netbsd || freebsd || openbsd || linux || dragonfly
+// +build darwin netbsd freebsd openbsd linux dragonfly
+
+package termios
+
+import "golang.org/x/sys/unix"
+
+func setSpeed(term *unix.Termios, ispeed, ospeed uint32) {
+ term.Ispeed = speed(ispeed)
+ term.Ospeed = speed(ospeed)
+}
+
+func getSpeed(term *unix.Termios) (uint32, uint32) {
+ return uint32(term.Ispeed), uint32(term.Ospeed)
+}
diff --git a/vendor/github.com/charmbracelet/x/termios/termios_solaris.go b/vendor/github.com/charmbracelet/x/termios/termios_solaris.go
new file mode 100644
index 000000000..129a38190
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/termios/termios_solaris.go
@@ -0,0 +1,26 @@
+//go:build solaris
+// +build solaris
+
+package termios
+
+import "golang.org/x/sys/unix"
+
+// see https://src.illumos.org/source/xref/illumos-gate/usr/src/lib/libc/port/gen/isatty.c
+// see https://github.com/omniti-labs/illumos-omnios/blob/master/usr/src/uts/common/sys/termios.h
+const (
+ ioctlSets = unix.TCSETA
+ ioctlGets = unix.TCGETA
+ ioctlSetWinSize = (int('T') << 8) | 103
+ ioctlGetWinSize = (int('T') << 8) | 104
+)
+
+func setSpeed(*unix.Termios, uint32, uint32) {
+ // TODO: support setting speed on Solaris?
+ // see cfgetospeed(3C) and cfsetospeed(3C)
+ // see cfgetispeed(3C) and cfsetispeed(3C)
+ // https://github.com/omniti-labs/illumos-omnios/blob/master/usr/src/uts/common/sys/termios.h#L103
+}
+
+func getSpeed(*unix.Termios) (uint32, uint32) {
+ return 0, 0
+}
diff --git a/vendor/github.com/charmbracelet/x/windows/LICENSE b/vendor/github.com/charmbracelet/x/windows/LICENSE
new file mode 100644
index 000000000..65a5654e2
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/windows/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Charmbracelet, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/charmbracelet/x/windows/doc.go b/vendor/github.com/charmbracelet/x/windows/doc.go
new file mode 100644
index 000000000..e99399084
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/windows/doc.go
@@ -0,0 +1,4 @@
+// Package windows provides Windows-specific system utilities.
+package windows
+
+//go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go syscall_windows.go
diff --git a/vendor/github.com/charmbracelet/x/windows/syscall_windows.go b/vendor/github.com/charmbracelet/x/windows/syscall_windows.go
new file mode 100644
index 000000000..48c9b307d
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/windows/syscall_windows.go
@@ -0,0 +1,14 @@
+package windows
+
+import "golang.org/x/sys/windows"
+
+// NewLazySystemDLL is a type alias for windows.NewLazySystemDLL.
+var NewLazySystemDLL = windows.NewLazySystemDLL
+
+// Handle is a type alias for windows.Handle.
+type Handle = windows.Handle
+
+//sys ReadConsoleInput(console Handle, buf *InputRecord, toread uint32, read *uint32) (err error) = kernel32.ReadConsoleInputW
+//sys PeekConsoleInput(console Handle, buf *InputRecord, toread uint32, read *uint32) (err error) = kernel32.PeekConsoleInputW
+//sys GetNumberOfConsoleInputEvents(console Handle, numevents *uint32) (err error) = kernel32.GetNumberOfConsoleInputEvents
+//sys FlushConsoleInputBuffer(console Handle) (err error) = kernel32.FlushConsoleInputBuffer
diff --git a/vendor/github.com/charmbracelet/x/windows/types.go b/vendor/github.com/charmbracelet/x/windows/types.go
new file mode 100644
index 000000000..0fd93c949
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/windows/types.go
@@ -0,0 +1,221 @@
+package windows
+
+// Virtual Key codes
+// https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
+//
+//nolint:revive
+const (
+ VK_LBUTTON = 0x01
+ VK_RBUTTON = 0x02
+ VK_CANCEL = 0x03
+ VK_MBUTTON = 0x04
+ VK_XBUTTON1 = 0x05
+ VK_XBUTTON2 = 0x06
+ VK_BACK = 0x08
+ VK_TAB = 0x09
+ VK_CLEAR = 0x0C
+ VK_RETURN = 0x0D
+ VK_SHIFT = 0x10
+ VK_CONTROL = 0x11
+ VK_MENU = 0x12
+ VK_PAUSE = 0x13
+ VK_CAPITAL = 0x14
+ VK_KANA = 0x15
+ VK_HANGEUL = 0x15
+ VK_HANGUL = 0x15
+ VK_IME_ON = 0x16
+ VK_JUNJA = 0x17
+ VK_FINAL = 0x18
+ VK_HANJA = 0x19
+ VK_KANJI = 0x19
+ VK_IME_OFF = 0x1A
+ VK_ESCAPE = 0x1B
+ VK_CONVERT = 0x1C
+ VK_NONCONVERT = 0x1D
+ VK_ACCEPT = 0x1E
+ VK_MODECHANGE = 0x1F
+ VK_SPACE = 0x20
+ VK_PRIOR = 0x21
+ VK_NEXT = 0x22
+ VK_END = 0x23
+ VK_HOME = 0x24
+ VK_LEFT = 0x25
+ VK_UP = 0x26
+ VK_RIGHT = 0x27
+ VK_DOWN = 0x28
+ VK_SELECT = 0x29
+ VK_PRINT = 0x2A
+ VK_EXECUTE = 0x2B
+ VK_SNAPSHOT = 0x2C
+ VK_INSERT = 0x2D
+ VK_DELETE = 0x2E
+ VK_HELP = 0x2F
+ VK_LWIN = 0x5B
+ VK_RWIN = 0x5C
+ VK_APPS = 0x5D
+ VK_SLEEP = 0x5F
+ VK_NUMPAD0 = 0x60
+ VK_NUMPAD1 = 0x61
+ VK_NUMPAD2 = 0x62
+ VK_NUMPAD3 = 0x63
+ VK_NUMPAD4 = 0x64
+ VK_NUMPAD5 = 0x65
+ VK_NUMPAD6 = 0x66
+ VK_NUMPAD7 = 0x67
+ VK_NUMPAD8 = 0x68
+ VK_NUMPAD9 = 0x69
+ VK_MULTIPLY = 0x6A
+ VK_ADD = 0x6B
+ VK_SEPARATOR = 0x6C
+ VK_SUBTRACT = 0x6D
+ VK_DECIMAL = 0x6E
+ VK_DIVIDE = 0x6F
+ VK_F1 = 0x70
+ VK_F2 = 0x71
+ VK_F3 = 0x72
+ VK_F4 = 0x73
+ VK_F5 = 0x74
+ VK_F6 = 0x75
+ VK_F7 = 0x76
+ VK_F8 = 0x77
+ VK_F9 = 0x78
+ VK_F10 = 0x79
+ VK_F11 = 0x7A
+ VK_F12 = 0x7B
+ VK_F13 = 0x7C
+ VK_F14 = 0x7D
+ VK_F15 = 0x7E
+ VK_F16 = 0x7F
+ VK_F17 = 0x80
+ VK_F18 = 0x81
+ VK_F19 = 0x82
+ VK_F20 = 0x83
+ VK_F21 = 0x84
+ VK_F22 = 0x85
+ VK_F23 = 0x86
+ VK_F24 = 0x87
+ VK_NUMLOCK = 0x90
+ VK_SCROLL = 0x91
+ VK_OEM_NEC_EQUAL = 0x92
+ VK_OEM_FJ_JISHO = 0x92
+ VK_OEM_FJ_MASSHOU = 0x93
+ VK_OEM_FJ_TOUROKU = 0x94
+ VK_OEM_FJ_LOYA = 0x95
+ VK_OEM_FJ_ROYA = 0x96
+ VK_LSHIFT = 0xA0
+ VK_RSHIFT = 0xA1
+ VK_LCONTROL = 0xA2
+ VK_RCONTROL = 0xA3
+ VK_LMENU = 0xA4
+ VK_RMENU = 0xA5
+ VK_BROWSER_BACK = 0xA6
+ VK_BROWSER_FORWARD = 0xA7
+ VK_BROWSER_REFRESH = 0xA8
+ VK_BROWSER_STOP = 0xA9
+ VK_BROWSER_SEARCH = 0xAA
+ VK_BROWSER_FAVORITES = 0xAB
+ VK_BROWSER_HOME = 0xAC
+ VK_VOLUME_MUTE = 0xAD
+ VK_VOLUME_DOWN = 0xAE
+ VK_VOLUME_UP = 0xAF
+ VK_MEDIA_NEXT_TRACK = 0xB0
+ VK_MEDIA_PREV_TRACK = 0xB1
+ VK_MEDIA_STOP = 0xB2
+ VK_MEDIA_PLAY_PAUSE = 0xB3
+ VK_LAUNCH_MAIL = 0xB4
+ VK_LAUNCH_MEDIA_SELECT = 0xB5
+ VK_LAUNCH_APP1 = 0xB6
+ VK_LAUNCH_APP2 = 0xB7
+ VK_OEM_1 = 0xBA
+ VK_OEM_PLUS = 0xBB
+ VK_OEM_COMMA = 0xBC
+ VK_OEM_MINUS = 0xBD
+ VK_OEM_PERIOD = 0xBE
+ VK_OEM_2 = 0xBF
+ VK_OEM_3 = 0xC0
+ VK_OEM_4 = 0xDB
+ VK_OEM_5 = 0xDC
+ VK_OEM_6 = 0xDD
+ VK_OEM_7 = 0xDE
+ VK_OEM_8 = 0xDF
+ VK_OEM_AX = 0xE1
+ VK_OEM_102 = 0xE2
+ VK_ICO_HELP = 0xE3
+ VK_ICO_00 = 0xE4
+ VK_PROCESSKEY = 0xE5
+ VK_ICO_CLEAR = 0xE6
+ VK_OEM_RESET = 0xE9
+ VK_OEM_JUMP = 0xEA
+ VK_OEM_PA1 = 0xEB
+ VK_OEM_PA2 = 0xEC
+ VK_OEM_PA3 = 0xED
+ VK_OEM_WSCTRL = 0xEE
+ VK_OEM_CUSEL = 0xEF
+ VK_OEM_ATTN = 0xF0
+ VK_OEM_FINISH = 0xF1
+ VK_OEM_COPY = 0xF2
+ VK_OEM_AUTO = 0xF3
+ VK_OEM_ENLW = 0xF4
+ VK_OEM_BACKTAB = 0xF5
+ VK_ATTN = 0xF6
+ VK_CRSEL = 0xF7
+ VK_EXSEL = 0xF8
+ VK_EREOF = 0xF9
+ VK_PLAY = 0xFA
+ VK_ZOOM = 0xFB
+ VK_NONAME = 0xFC
+ VK_PA1 = 0xFD
+ VK_OEM_CLEAR = 0xFE
+)
+
+// Mouse button constants.
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str
+//
+//nolint:revive
+const (
+ FROM_LEFT_1ST_BUTTON_PRESSED = 0x0001
+ RIGHTMOST_BUTTON_PRESSED = 0x0002
+ FROM_LEFT_2ND_BUTTON_PRESSED = 0x0004
+ FROM_LEFT_3RD_BUTTON_PRESSED = 0x0008
+ FROM_LEFT_4TH_BUTTON_PRESSED = 0x0010
+)
+
+// Control key state constraints.
+// https://docs.microsoft.com/en-us/windows/console/key-event-record-str
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str
+//
+//nolint:revive
+const (
+ CAPSLOCK_ON = 0x0080
+ ENHANCED_KEY = 0x0100
+ LEFT_ALT_PRESSED = 0x0002
+ LEFT_CTRL_PRESSED = 0x0008
+ NUMLOCK_ON = 0x0020
+ RIGHT_ALT_PRESSED = 0x0001
+ RIGHT_CTRL_PRESSED = 0x0004
+ SCROLLLOCK_ON = 0x0040
+ SHIFT_PRESSED = 0x0010
+)
+
+// Mouse event record event flags.
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str
+//
+//nolint:revive
+const (
+ MOUSE_MOVED = 0x0001
+ DOUBLE_CLICK = 0x0002
+ MOUSE_WHEELED = 0x0004
+ MOUSE_HWHEELED = 0x0008
+)
+
+// Input Record Event Types
+// https://learn.microsoft.com/en-us/windows/console/input-record-str
+//
+//nolint:revive
+const (
+ FOCUS_EVENT = 0x0010
+ KEY_EVENT = 0x0001
+ MENU_EVENT = 0x0008
+ MOUSE_EVENT = 0x0002
+ WINDOW_BUFFER_SIZE_EVENT = 0x0004
+)
diff --git a/vendor/github.com/charmbracelet/x/windows/types_windows.go b/vendor/github.com/charmbracelet/x/windows/types_windows.go
new file mode 100644
index 000000000..272eeaab5
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/windows/types_windows.go
@@ -0,0 +1,142 @@
+//nolint:gosec
+package windows
+
+import (
+ "encoding/binary"
+
+ "golang.org/x/sys/windows"
+)
+
+// FocusEventRecord corresponds to the FocusEventRecord structure from the
+// Windows console API.
+// https://docs.microsoft.com/en-us/windows/console/focus-event-record-str
+type FocusEventRecord struct {
+ // SetFocus is reserved and should not be used.
+ SetFocus bool
+}
+
+// KeyEventRecord corresponds to the KeyEventRecord structure from the Windows
+// console API.
+// https://docs.microsoft.com/en-us/windows/console/key-event-record-str
+type KeyEventRecord struct {
+ // KeyDown specified whether the key is pressed or released.
+ KeyDown bool
+
+ // RepeatCount indicates that a key is being held down. For example, when a
+ // key is held down, five events with RepeatCount equal to 1 may be
+ // generated, one event with RepeatCount equal to 5, or multiple events
+ // with RepeatCount greater than or equal to 1.
+ RepeatCount uint16
+
+ // VirtualKeyCode identifies the given key in a device-independent manner
+ // (see
+ // https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes).
+ VirtualKeyCode uint16
+
+ // VirtualScanCode represents the device-dependent value generated by the
+ // keyboard hardware.
+ VirtualScanCode uint16
+
+ // Char is the character that corresponds to the pressed key. Char can be
+ // zero for some keys.
+ Char rune
+
+ // ControlKeyState holds the state of the control keys.
+ ControlKeyState uint32
+}
+
+// MenuEventRecord corresponds to the MenuEventRecord structure from the
+// Windows console API.
+// https://docs.microsoft.com/en-us/windows/console/menu-event-record-str
+type MenuEventRecord struct {
+ CommandID uint32
+}
+
+// MouseEventRecord corresponds to the MouseEventRecord structure from the
+// Windows console API.
+// https://docs.microsoft.com/en-us/windows/console/mouse-event-record-str
+type MouseEventRecord struct {
+ // MousePosition contains the location of the cursor, in terms of the
+ // console screen buffer's character-cell coordinates.
+ MousePositon windows.Coord
+
+ // ButtonState holds the status of the mouse buttons.
+ ButtonState uint32
+
+ // ControlKeyState holds the state of the control keys.
+ ControlKeyState uint32
+
+ // EventFlags specify the type of mouse event.
+ EventFlags uint32
+}
+
+// WindowBufferSizeRecord corresponds to the WindowBufferSizeRecord structure
+// from the Windows console API.
+// https://docs.microsoft.com/en-us/windows/console/window-buffer-size-record-str
+type WindowBufferSizeRecord struct {
+ // Size contains the size of the console screen buffer, in character cell
+ // columns and rows.
+ Size windows.Coord
+}
+
+// InputRecord corresponds to the INPUT_RECORD structure from the Windows
+// console API.
+//
+// https://docs.microsoft.com/en-us/windows/console/input-record-str
+type InputRecord struct {
+ // EventType specifies the type of event that helt in Event.
+ EventType uint16
+
+ // Padding of the 16-bit EventType to a whole 32-bit dword.
+ _ [2]byte
+
+ // Event holds the actual event data.
+ Event [16]byte
+}
+
+// FocusEvent returns the event as a FOCUS_EVENT_RECORD.
+func (ir InputRecord) FocusEvent() FocusEventRecord {
+ return FocusEventRecord{SetFocus: ir.Event[0] > 0}
+}
+
+// KeyEvent returns the event as a KEY_EVENT_RECORD.
+func (ir InputRecord) KeyEvent() KeyEventRecord {
+ return KeyEventRecord{
+ KeyDown: binary.LittleEndian.Uint32(ir.Event[0:4]) > 0,
+ RepeatCount: binary.LittleEndian.Uint16(ir.Event[4:6]),
+ VirtualKeyCode: binary.LittleEndian.Uint16(ir.Event[6:8]),
+ VirtualScanCode: binary.LittleEndian.Uint16(ir.Event[8:10]),
+ Char: rune(binary.LittleEndian.Uint16(ir.Event[10:12])),
+ ControlKeyState: binary.LittleEndian.Uint32(ir.Event[12:16]),
+ }
+}
+
+// MouseEvent returns the event as a MOUSE_EVENT_RECORD.
+func (ir InputRecord) MouseEvent() MouseEventRecord {
+ return MouseEventRecord{
+ MousePositon: windows.Coord{
+ X: int16(binary.LittleEndian.Uint16(ir.Event[0:2])),
+ Y: int16(binary.LittleEndian.Uint16(ir.Event[2:4])),
+ },
+ ButtonState: binary.LittleEndian.Uint32(ir.Event[4:8]),
+ ControlKeyState: binary.LittleEndian.Uint32(ir.Event[8:12]),
+ EventFlags: binary.LittleEndian.Uint32(ir.Event[12:16]),
+ }
+}
+
+// WindowBufferSizeEvent returns the event as a WINDOW_BUFFER_SIZE_RECORD.
+func (ir InputRecord) WindowBufferSizeEvent() WindowBufferSizeRecord {
+ return WindowBufferSizeRecord{
+ Size: windows.Coord{
+ X: int16(binary.LittleEndian.Uint16(ir.Event[0:2])),
+ Y: int16(binary.LittleEndian.Uint16(ir.Event[2:4])),
+ },
+ }
+}
+
+// MenuEvent returns the event as a MENU_EVENT_RECORD.
+func (ir InputRecord) MenuEvent() MenuEventRecord {
+ return MenuEventRecord{
+ CommandID: binary.LittleEndian.Uint32(ir.Event[0:4]),
+ }
+}
diff --git a/vendor/github.com/charmbracelet/x/windows/zsyscall_windows.go b/vendor/github.com/charmbracelet/x/windows/zsyscall_windows.go
new file mode 100644
index 000000000..43412b84f
--- /dev/null
+++ b/vendor/github.com/charmbracelet/x/windows/zsyscall_windows.go
@@ -0,0 +1,77 @@
+// Code generated by 'go generate'; DO NOT EDIT.
+
+package windows
+
+import (
+ "syscall"
+ "unsafe"
+)
+
+var _ unsafe.Pointer
+
+// Do the interface allocations only once for common
+// Errno values.
+const (
+ errnoERROR_IO_PENDING = 997
+)
+
+var (
+ errERROR_IO_PENDING error = syscall.Errno(errnoERROR_IO_PENDING)
+ errERROR_EINVAL error = syscall.EINVAL
+)
+
+// errnoErr returns common boxed Errno values, to prevent
+// allocations at runtime.
+func errnoErr(e syscall.Errno) error {
+ switch e {
+ case 0:
+ return errERROR_EINVAL
+ case errnoERROR_IO_PENDING:
+ return errERROR_IO_PENDING
+ }
+ // TODO: add more here, after collecting data on the common
+ // error values see on Windows. (perhaps when running
+ // all.bat?)
+ return e
+}
+
+var (
+ modkernel32 = NewLazySystemDLL("kernel32.dll")
+
+ procFlushConsoleInputBuffer = modkernel32.NewProc("FlushConsoleInputBuffer")
+ procGetNumberOfConsoleInputEvents = modkernel32.NewProc("GetNumberOfConsoleInputEvents")
+ procPeekConsoleInputW = modkernel32.NewProc("PeekConsoleInputW")
+ procReadConsoleInputW = modkernel32.NewProc("ReadConsoleInputW")
+)
+
+func FlushConsoleInputBuffer(console Handle) (err error) {
+ r1, _, e1 := syscall.Syscall(procFlushConsoleInputBuffer.Addr(), 1, uintptr(console), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func GetNumberOfConsoleInputEvents(console Handle, numevents *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall(procGetNumberOfConsoleInputEvents.Addr(), 2, uintptr(console), uintptr(unsafe.Pointer(numevents)), 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func PeekConsoleInput(console Handle, buf *InputRecord, toread uint32, read *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procPeekConsoleInputW.Addr(), 4, uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(toread), uintptr(unsafe.Pointer(read)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
+
+func ReadConsoleInput(console Handle, buf *InputRecord, toread uint32, read *uint32) (err error) {
+ r1, _, e1 := syscall.Syscall6(procReadConsoleInputW.Addr(), 4, uintptr(console), uintptr(unsafe.Pointer(buf)), uintptr(toread), uintptr(unsafe.Pointer(read)), 0, 0)
+ if r1 == 0 {
+ err = errnoErr(e1)
+ }
+ return
+}
diff --git a/vendor/github.com/evertras/bubble-table/table/border.go b/vendor/github.com/evertras/bubble-table/table/border.go
index 756d4c814..68feefd4f 100644
--- a/vendor/github.com/evertras/bubble-table/table/border.go
+++ b/vendor/github.com/evertras/bubble-table/table/border.go
@@ -1,6 +1,11 @@
package table
-import "github.com/charmbracelet/lipgloss"
+import (
+ "image/color"
+ "strings"
+
+ "charm.land/lipgloss/v2"
+)
// Border defines the borders in and around the table.
type Border struct {
@@ -48,6 +53,10 @@ type Border struct {
// Style for the footer
styleFooter lipgloss.Style
+
+ // foreground is the colour applied to plain-string border lines (top,
+ // separator, bottom). nil means use the terminal default.
+ foreground color.Color
}
var (
@@ -105,21 +114,95 @@ func (b *Border) generateStyles() {
b.generateSingleRowStyles()
b.generateSingleCellStyle()
- // The footer is a single cell with the top taken off... usually. We can
- // re-enable the top if needed this way for certain format configurations.
- b.styleFooter = b.styleSingleCell.Copy().
+ // The footer is a full-width single cell with a bottom border. It needs
+ // the actual border characters for all edges because renderFooter may
+ // optionally add a top border (when there are no data rows above).
+ b.styleFooter = lipgloss.NewStyle().
+ BorderStyle(lipgloss.Border{
+ Left: b.Left,
+ Right: b.Right,
+
+ Top: b.Top,
+ TopLeft: b.TopLeft,
+ TopRight: b.TopRight,
+
+ Bottom: b.Bottom,
+ BottomLeft: b.BottomLeft,
+ BottomRight: b.BottomRight,
+ }).
Align(lipgloss.Right).
BorderBottom(true).
BorderRight(true).
BorderLeft(true)
}
+// buildBorderLine constructs a horizontal border line for the given column
+// widths. leftChar is the leftmost character, midChar fills each column,
+// junctionChar separates columns, and rightChar closes the line.
+// If b.foreground is set the line is wrapped in a lipgloss Foreground style
+// so that it renders in the same colour as the cell border characters.
+func (b *Border) buildBorderLine(columnWidths []int, leftChar, midChar, junctionChar, rightChar string) string {
+ var buf strings.Builder
+
+ buf.WriteString(leftChar)
+
+ for i, w := range columnWidths {
+ buf.WriteString(strings.Repeat(midChar, w))
+
+ if i < len(columnWidths)-1 {
+ buf.WriteString(junctionChar)
+ }
+ }
+
+ buf.WriteString(rightChar)
+
+ line := buf.String()
+
+ if b.foreground != nil {
+ line = lipgloss.NewStyle().Foreground(b.foreground).Render(line)
+ }
+
+ return line
+}
+
+// buildTopBorderLine builds the top border line for a multi-column table.
+func (b *Border) buildTopBorderLine(columnWidths []int) string {
+ return b.buildBorderLine(columnWidths, b.TopLeft, b.Top, b.TopJunction, b.TopRight)
+}
+
+// buildSeparatorLine builds the separator line between the header and first
+// data row for a multi-column table.
+func (b *Border) buildSeparatorLine(columnWidths []int) string {
+ return b.buildBorderLine(columnWidths, b.LeftJunction, b.Bottom, b.InnerJunction, b.RightJunction)
+}
+
+// buildInnerSeparatorLine builds a separator line with no outer junction
+// characters, used when the outer border is hidden.
+func (b *Border) buildInnerSeparatorLine(columnWidths []int) string {
+ return b.buildBorderLine(columnWidths, "", b.Bottom, b.InnerJunction, "")
+}
+
+// buildBottomBorderLine builds the bottom border line for a multi-column
+// table. When hasFooter is true the corners are replaced with junctions so
+// the footer can attach below.
+func (b *Border) buildBottomBorderLine(columnWidths []int, hasFooter bool) string {
+ left := b.BottomLeft
+ right := b.BottomRight
+
+ if hasFooter {
+ left = b.LeftJunction
+ right = b.RightJunction
+ }
+
+ return b.buildBorderLine(columnWidths, left, b.Bottom, b.BottomJunction, right)
+}
+
func (b *Border) styleLeftWithFooter(original lipgloss.Style) lipgloss.Style {
border := original.GetBorderStyle()
border.BottomLeft = b.LeftJunction
- return original.Copy().BorderStyle(border)
+ return original.BorderStyle(border)
}
func (b *Border) styleRightWithFooter(original lipgloss.Style) lipgloss.Style {
@@ -127,7 +210,7 @@ func (b *Border) styleRightWithFooter(original lipgloss.Style) lipgloss.Style {
border.BottomRight = b.RightJunction
- return original.Copy().BorderStyle(border)
+ return original.BorderStyle(border)
}
func (b *Border) styleBothWithFooter(original lipgloss.Style) lipgloss.Style {
@@ -136,47 +219,32 @@ func (b *Border) styleBothWithFooter(original lipgloss.Style) lipgloss.Style {
border.BottomLeft = b.LeftJunction
border.BottomRight = b.RightJunction
- return original.Copy().BorderStyle(border)
+ return original.BorderStyle(border)
}
-// This function is long, but it's just repetitive...
-//
-//nolint:funlen
func (b *Border) generateMultiStyles() {
+ // All cell styles have ONLY left and/or right borders.
+ // Top, bottom, and separator lines are rendered as plain strings by
+ // the header/row rendering functions, not by these styles.
+
b.styleMultiTopLeft = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- TopLeft: b.TopLeft,
- Top: b.Top,
- TopRight: b.TopJunction,
- Right: b.InnerDivider,
- BottomRight: b.InnerJunction,
- Bottom: b.Bottom,
- BottomLeft: b.LeftJunction,
- Left: b.Left,
+ Left: b.Left,
+ Right: b.InnerDivider,
},
- )
+ ).BorderLeft(true).BorderRight(true)
b.styleMultiTop = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Right: b.InnerDivider,
- Bottom: b.Bottom,
-
- TopRight: b.TopJunction,
- BottomRight: b.InnerJunction,
+ Right: b.InnerDivider,
},
- ).BorderTop(true).BorderBottom(true).BorderRight(true)
+ ).BorderRight(true)
b.styleMultiTopRight = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Right: b.Right,
- Bottom: b.Bottom,
-
- TopRight: b.TopRight,
- BottomRight: b.RightJunction,
+ Right: b.Right,
},
- ).BorderTop(true).BorderBottom(true).BorderRight(true)
+ ).BorderRight(true)
b.styleMultiLeft = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
@@ -199,48 +267,34 @@ func (b *Border) generateMultiStyles() {
b.styleMultiBottomLeft = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Left: b.Left,
- Right: b.InnerDivider,
- Bottom: b.Bottom,
-
- BottomLeft: b.BottomLeft,
- BottomRight: b.BottomJunction,
+ Left: b.Left,
+ Right: b.InnerDivider,
},
- ).BorderLeft(true).BorderBottom(true).BorderRight(true)
+ ).BorderLeft(true).BorderRight(true)
b.styleMultiBottom = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Right: b.InnerDivider,
- Bottom: b.Bottom,
-
- BottomRight: b.BottomJunction,
+ Right: b.InnerDivider,
},
- ).BorderBottom(true).BorderRight(true)
+ ).BorderRight(true)
b.styleMultiBottomRight = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Right: b.Right,
- Bottom: b.Bottom,
-
- BottomRight: b.BottomRight,
+ Right: b.Right,
},
- ).BorderBottom(true).BorderRight(true)
+ ).BorderRight(true)
}
func (b *Border) generateSingleColumnStyles() {
+ // Cell styles have only left/right borders; top/bottom border lines are
+ // built as plain strings by the rendering functions.
+
b.styleSingleColumnTop = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Left: b.Left,
- Right: b.Right,
- Bottom: b.Bottom,
-
- TopLeft: b.TopLeft,
- TopRight: b.TopRight,
- BottomLeft: b.LeftJunction,
- BottomRight: b.RightJunction,
+ Left: b.Left,
+ Right: b.Right,
},
- )
+ ).BorderLeft(true).BorderRight(true)
b.styleSingleColumnInner = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
@@ -251,83 +305,62 @@ func (b *Border) generateSingleColumnStyles() {
b.styleSingleColumnBottom = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Left: b.Left,
- Right: b.Right,
- Bottom: b.Bottom,
-
- BottomLeft: b.BottomLeft,
- BottomRight: b.BottomRight,
+ Left: b.Left,
+ Right: b.Right,
},
- ).BorderRight(true).BorderLeft(true).BorderBottom(true)
+ ).BorderRight(true).BorderLeft(true)
}
func (b *Border) generateSingleRowStyles() {
+ // Cell styles have only left/right borders; top/bottom border lines are
+ // built as plain strings by the rendering functions.
+
b.styleSingleRowLeft = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Left: b.Left,
- Right: b.InnerDivider,
- Bottom: b.Bottom,
-
- BottomLeft: b.BottomLeft,
- BottomRight: b.BottomJunction,
- TopRight: b.TopJunction,
- TopLeft: b.TopLeft,
+ Left: b.Left,
+ Right: b.InnerDivider,
},
- )
+ ).BorderLeft(true).BorderRight(true)
b.styleSingleRowInner = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Right: b.InnerDivider,
- Bottom: b.Bottom,
-
- BottomRight: b.BottomJunction,
- TopRight: b.TopJunction,
+ Right: b.InnerDivider,
},
- ).BorderTop(true).BorderBottom(true).BorderRight(true)
+ ).BorderRight(true)
b.styleSingleRowRight = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Right: b.Right,
- Bottom: b.Bottom,
-
- BottomRight: b.BottomRight,
- TopRight: b.TopRight,
+ Right: b.Right,
},
- ).BorderTop(true).BorderBottom(true).BorderRight(true)
+ ).BorderRight(true)
}
func (b *Border) generateSingleCellStyle() {
+ // Cell style has only left/right borders; top/bottom border lines are
+ // built as plain strings by the rendering functions.
b.styleSingleCell = lipgloss.NewStyle().BorderStyle(
lipgloss.Border{
- Top: b.Top,
- Left: b.Left,
- Right: b.Right,
- Bottom: b.Bottom,
-
- BottomLeft: b.BottomLeft,
- BottomRight: b.BottomRight,
- TopRight: b.TopRight,
- TopLeft: b.TopLeft,
+ Left: b.Left,
+ Right: b.Right,
},
- )
+ ).BorderLeft(true).BorderRight(true)
}
// BorderDefault uses the basic square border, useful to reset the border if
// it was changed somehow.
func (m Model) BorderDefault() Model {
- // Already generated styles
+ fg := m.border.foreground
m.border = borderDefault
+ m.border.foreground = fg
return m
}
// BorderRounded uses a thin, rounded border.
func (m Model) BorderRounded() Model {
- // Already generated styles
+ fg := m.border.foreground
m.border = borderRounded
+ m.border.foreground = fg
return m
}
@@ -348,9 +381,9 @@ type borderStyleRow struct {
}
func (b *borderStyleRow) inherit(s lipgloss.Style) {
- b.left = b.left.Copy().Inherit(s)
- b.inner = b.inner.Copy().Inherit(s)
- b.right = b.right.Copy().Inherit(s)
+ b.left = b.left.Inherit(s)
+ b.inner = b.inner.Inherit(s)
+ b.right = b.right.Inherit(s)
}
// There's a lot of branches here, but splitting it up further would make it
@@ -403,6 +436,19 @@ func (m Model) styleHeaders() borderStyleRow {
styles.inherit(m.headerStyle)
+ // HeaderStyle is for text styling only. Strip any border-side flags that
+ // may have been inherited: top/bottom border lines are rendered as separate
+ // plain strings, and inner/right cells never carry a left border (each
+ // column's left divider is provided by the previous column's right border).
+ styles.left = styles.left.BorderTop(false).BorderBottom(false)
+ styles.inner = styles.inner.BorderTop(false).BorderBottom(false).BorderLeft(false)
+ styles.right = styles.right.BorderTop(false).BorderBottom(false).BorderLeft(false)
+
+ if !m.outerBorder {
+ styles.left = styles.left.BorderLeft(false)
+ styles.right = styles.right.BorderRight(false)
+ }
+
return styles
}
@@ -435,5 +481,12 @@ func (m Model) styleRows() (inner borderStyleRow, last borderStyleRow) {
}
}
+ if !m.outerBorder {
+ inner.left = inner.left.BorderLeft(false)
+ inner.right = inner.right.BorderRight(false)
+ last.left = last.left.BorderLeft(false)
+ last.right = last.right.BorderRight(false)
+ }
+
return inner, last
}
diff --git a/vendor/github.com/evertras/bubble-table/table/calc.go b/vendor/github.com/evertras/bubble-table/table/calc.go
index 3f0db046b..406763eb3 100644
--- a/vendor/github.com/evertras/bubble-table/table/calc.go
+++ b/vendor/github.com/evertras/bubble-table/table/calc.go
@@ -1,21 +1,5 @@
package table
-func min(x, y int) int {
- if x < y {
- return x
- }
-
- return y
-}
-
-func max(x, y int) int {
- if x > y {
- return x
- }
-
- return y
-}
-
// These var names are fine for this little function
//
//nolint:varnamelen
diff --git a/vendor/github.com/evertras/bubble-table/table/cell.go b/vendor/github.com/evertras/bubble-table/table/cell.go
index 55156e76f..729acb2ed 100644
--- a/vendor/github.com/evertras/bubble-table/table/cell.go
+++ b/vendor/github.com/evertras/bubble-table/table/cell.go
@@ -1,6 +1,6 @@
package table
-import "github.com/charmbracelet/lipgloss"
+import "charm.land/lipgloss/v2"
// StyledCell represents a cell in the table that has a particular style applied.
// The cell style takes highest precedence and will overwrite more general styles
@@ -8,12 +8,53 @@ import "github.com/charmbracelet/lipgloss"
// limited to colors, font style, and alignments - spacing style such as margin
// will break the table format.
type StyledCell struct {
- Data interface{}
+ // Data is the content of the cell.
+ Data any
+
+ // Style is the specific style to apply. This is ignored if StyleFunc is not nil.
Style lipgloss.Style
+
+ // StyleFunc is a function that takes the row/column of the cell and
+ // returns a lipgloss.Style allowing for dynamic styling based on the cell's
+ // content or position. Overrides Style if set.
+ StyleFunc StyledCellFunc
+}
+
+// StyledCellFuncInput is the input to the StyledCellFunc. Sent as a struct
+// to allow for future additions without breaking changes.
+type StyledCellFuncInput struct {
+ // Data is the data in the cell.
+ Data any
+
+ // Column is the column that the cell belongs to.
+ Column Column
+
+ // Row is the row that the cell belongs to.
+ Row Row
+
+ // GlobalMetadata is the global table metadata that's been set by WithGlobalMetadata
+ GlobalMetadata map[string]any
}
+// StyledCellFunc is a function that takes various information about the cell and
+// returns a lipgloss.Style allowing for easier dynamic styling based on the cell's
+// content or position.
+type StyledCellFunc = func(input StyledCellFuncInput) lipgloss.Style
+
// NewStyledCell creates an entry that can be set in the row data and show as
// styled with the given style.
-func NewStyledCell(data interface{}, style lipgloss.Style) StyledCell {
- return StyledCell{data, style}
+func NewStyledCell(data any, style lipgloss.Style) StyledCell {
+ return StyledCell{
+ Data: data,
+ Style: style,
+ }
+}
+
+// NewStyledCellWithStyleFunc creates an entry that can be set in the row data and show as
+// styled with the given style function.
+func NewStyledCellWithStyleFunc(data any, styleFunc StyledCellFunc) StyledCell {
+ return StyledCell{
+ Data: data,
+ StyleFunc: styleFunc,
+ }
}
diff --git a/vendor/github.com/evertras/bubble-table/table/column.go b/vendor/github.com/evertras/bubble-table/table/column.go
index 9a55fddb2..07f444419 100644
--- a/vendor/github.com/evertras/bubble-table/table/column.go
+++ b/vendor/github.com/evertras/bubble-table/table/column.go
@@ -1,7 +1,7 @@
package table
import (
- "github.com/charmbracelet/lipgloss"
+ "charm.land/lipgloss/v2"
)
// Column is a column in the table.
@@ -47,7 +47,7 @@ func NewFlexColumn(key, title string, flexFactor int) Column {
// WithStyle applies a style to the column as a whole.
func (c Column) WithStyle(style lipgloss.Style) Column {
- c.style = style.Copy().Width(c.width)
+ c.style = style.Width(c.width)
return c
}
@@ -64,7 +64,7 @@ func (c Column) WithFiltered(filterable bool) Column {
// If not set, the default is "%v" for all data types. Intended mainly for
// numeric formatting.
//
-// Since data is of the interface{} type, make sure that all data in the column
+// Since data is of the any type, make sure that all data in the column
// is of the expected type or the format may fail. For example, hardcoding '3'
// instead of '3.0' and using '%.2f' will fail because '3' is an integer.
func (c Column) WithFormatString(fmtString string) Column {
diff --git a/vendor/github.com/evertras/bubble-table/table/data.go b/vendor/github.com/evertras/bubble-table/table/data.go
index 73d558a04..a0ed46952 100644
--- a/vendor/github.com/evertras/bubble-table/table/data.go
+++ b/vendor/github.com/evertras/bubble-table/table/data.go
@@ -2,10 +2,22 @@ package table
import "time"
+func asTime(data any) (time.Time, bool) {
+ switch val := data.(type) {
+ case time.Time:
+ return val, true
+
+ case StyledCell:
+ return asTime(val.Data)
+ }
+
+ return time.Time{}, false
+}
+
// This is just a bunch of data type checks, so... no linting here
//
//nolint:cyclop
-func asInt(data interface{}) (int64, bool) {
+func asInt(data any) (int64, bool) {
switch val := data.(type) {
case int:
return int64(val), true
@@ -23,6 +35,7 @@ func asInt(data interface{}) (int64, bool) {
return val, true
case uint:
+ // #nosec: G115
return int64(val), true
case uint8:
@@ -35,6 +48,7 @@ func asInt(data interface{}) (int64, bool) {
return int64(val), true
case uint64:
+ // #nosec: G115
return int64(val), true
case time.Duration:
@@ -47,7 +61,7 @@ func asInt(data interface{}) (int64, bool) {
return 0, false
}
-func asNumber(data interface{}) (float64, bool) {
+func asNumber(data any) (float64, bool) {
switch val := data.(type) {
case float32:
return float64(val), true
diff --git a/vendor/github.com/evertras/bubble-table/table/dimensions.go b/vendor/github.com/evertras/bubble-table/table/dimensions.go
index 380746160..d5e0623d2 100644
--- a/vendor/github.com/evertras/bubble-table/table/dimensions.go
+++ b/vendor/github.com/evertras/bubble-table/table/dimensions.go
@@ -1,7 +1,7 @@
package table
import (
- "github.com/charmbracelet/lipgloss"
+ "charm.land/lipgloss/v2"
)
func (m *Model) recalculateWidth() {
@@ -29,10 +29,12 @@ func updateColumnWidths(cols []Column, totalWidth int) {
totalFlexFactor := 0
flexGCD := 0
- for index, col := range cols {
+ for _, col := range cols {
if !col.isFlex() {
totalFlexWidth -= col.width
- cols[index].style = col.style.Width(col.width)
+ // Do not set Width on col.style here; the rendering functions apply
+ // Width(column.width + borderOverhead) at render time to correctly
+ // account for lipgloss v2's total-outer-width semantics.
} else {
totalFlexFactor += col.flexFactor
flexGCD = gcd(flexGCD, col.flexFactor)
@@ -71,8 +73,8 @@ func updateColumnWidths(cols []Column, totalWidth int) {
cols[index].width = width
- // Take borders into account for the actual style
- cols[index].style = cols[index].style.Width(width)
+ // Do not set Width on the style; rendering functions apply
+ // Width(column.width + borderOverhead) at render time.
}
}
@@ -92,6 +94,71 @@ func (m *Model) recalculateHeight() {
m.metaHeight = headerHeight + footerHeight
}
+// ensurePageMap rebuilds the page-start index cache if it is stale.
+// For targetHeight mode it uses a two-pass approach: first calculate without a
+// footer to determine whether multiple pages are needed, then if they are,
+// recalculate with the footer included in the height budget and rebuild.
+func (m *Model) ensurePageMap() {
+ if m.pageStartIndices == nil {
+ m.recalculateHeight()
+ m.buildPageStartIndices()
+
+ if m.targetHeight != 0 && len(m.pageStartIndices) > 1 {
+ // Footer is now active (multi-page); redo with footer in budget.
+ m.recalculateHeight()
+ m.buildPageStartIndices()
+ }
+ }
+}
+
+// buildPageStartIndices computes which row index each page starts on and stores
+// the result in m.pageStartIndices. Must be called after recalculateHeight so
+// that m.metaHeight is up to date.
+func (m *Model) buildPageStartIndices() {
+ rows := m.GetVisibleRows()
+
+ if len(rows) == 0 {
+ m.pageStartIndices = []int{}
+
+ return
+ }
+
+ // metaHeight covers the header (including top border) and footer.
+ // The bottom border is appended to the last data row by assembleRowOutput,
+ // so subtract 1 more to account for it.
+ availableLines := m.targetHeight - m.metaHeight - 1
+
+ if availableLines < 1 {
+ availableLines = 1
+ }
+
+ pageStarts := []int{0}
+ currentPageLines := 0
+
+ for rowIdx, row := range rows {
+ rowLines := m.rowLineCount(row)
+
+ var linesNeeded int
+ if currentPageLines == 0 {
+ linesNeeded = rowLines
+ } else if m.rowSeparator {
+ linesNeeded = rowLines + 1 // separator between rows
+ } else {
+ linesNeeded = rowLines
+ }
+
+ if currentPageLines+linesNeeded > availableLines && currentPageLines > 0 {
+ // Row doesn't fit on the current page; start a new one.
+ pageStarts = append(pageStarts, rowIdx)
+ currentPageLines = m.rowLineCount(row)
+ } else {
+ currentPageLines += linesNeeded
+ }
+ }
+
+ m.pageStartIndices = pageStarts
+}
+
func (m *Model) calculatePadding(numRows int) int {
if m.minimumHeight == 0 {
return 0
diff --git a/vendor/github.com/evertras/bubble-table/table/events.go b/vendor/github.com/evertras/bubble-table/table/events.go
index 4b5e2b09d..b519623dc 100644
--- a/vendor/github.com/evertras/bubble-table/table/events.go
+++ b/vendor/github.com/evertras/bubble-table/table/events.go
@@ -3,7 +3,7 @@ package table
// UserEvent is some state change that has occurred due to user input. These will
// ONLY be generated when a user has interacted directly with the table. These
// will NOT be generated when code programmatically changes values in the table.
-type UserEvent interface{}
+type UserEvent any
func (m *Model) appendUserEvent(e UserEvent) {
m.lastUpdateUserEvents = append(m.lastUpdateUserEvents, e)
diff --git a/vendor/github.com/evertras/bubble-table/table/filter.go b/vendor/github.com/evertras/bubble-table/table/filter.go
index 0ba233b86..adcb15481 100644
--- a/vendor/github.com/evertras/bubble-table/table/filter.go
+++ b/vendor/github.com/evertras/bubble-table/table/filter.go
@@ -5,6 +5,26 @@ import (
"strings"
)
+// FilterFuncInput is the input to a FilterFunc. It's a struct so we can add more things later
+// without breaking compatibility.
+type FilterFuncInput struct {
+ // Columns is a list of the columns of the table
+ Columns []Column
+
+ // Row is the row that's being considered for filtering
+ Row Row
+
+ // GlobalMetadata is an arbitrary set of metadata from the table set by WithGlobalMetadata
+ GlobalMetadata map[string]any
+
+ // Filter is the filter string input to consider
+ Filter string
+}
+
+// FilterFunc takes a FilterFuncInput and returns true if the row should be visible,
+// or false if the row should be hidden.
+type FilterFunc func(FilterFuncInput) bool
+
func (m Model) getFilteredRows(rows []Row) []Row {
filterInputValue := m.filterTextInput.Value()
if !m.filtered || filterInputValue == "" {
@@ -14,7 +34,20 @@ func (m Model) getFilteredRows(rows []Row) []Row {
filteredRows := make([]Row, 0)
for _, row := range rows {
- if isRowMatched(m.columns, row, filterInputValue) {
+ var availableFilterFunc FilterFunc
+
+ if m.filterFunc != nil {
+ availableFilterFunc = m.filterFunc
+ } else {
+ availableFilterFunc = filterFuncContains
+ }
+
+ if availableFilterFunc(FilterFuncInput{
+ Columns: m.columns,
+ Row: row,
+ Filter: filterInputValue,
+ GlobalMetadata: m.metadata,
+ }) {
filteredRows = append(filteredRows, row)
}
}
@@ -22,23 +55,25 @@ func (m Model) getFilteredRows(rows []Row) []Row {
return filteredRows
}
-func isRowMatched(columns []Column, row Row, filter string) bool {
- if filter == "" {
+// filterFuncContains returns a filterFunc that performs case-insensitive
+// "contains" matching over all filterable columns in a row.
+func filterFuncContains(input FilterFuncInput) bool {
+ if input.Filter == "" {
return true
}
checkedAny := false
- filterLower := strings.ToLower(filter)
+ filterLower := strings.ToLower(input.Filter)
- for _, column := range columns {
+ for _, column := range input.Columns {
if !column.filterable {
continue
}
checkedAny = true
- data, ok := row.Data[column.key]
+ data, ok := input.Row.Data[column.key]
if !ok {
continue
@@ -69,3 +104,79 @@ func isRowMatched(columns []Column, row Row, filter string) bool {
return !checkedAny
}
+
+// filterFuncFuzzy returns a filterFunc that performs case-insensitive fuzzy
+// matching (subsequence) over the concatenation of all filterable column values.
+// it supports multiple filter tokens separated by space which must all match.
+// also, if a filter token starts with the quote character (') it has to match literally.
+func filterFuncFuzzy(input FilterFuncInput) bool {
+ filter := strings.TrimSpace(input.Filter)
+ if filter == "" {
+ return true
+ }
+
+ haystack := buildFuzzyHaystack(input)
+ if haystack == "" {
+ return false
+ }
+
+ for _, token := range strings.Fields(strings.ToLower(filter)) {
+ if !fuzzyTokenMatches(haystack, token) {
+ return false
+ }
+ }
+
+ return true
+}
+
+func buildFuzzyHaystack(input FilterFuncInput) string {
+ var builder strings.Builder
+
+ for _, col := range input.Columns {
+ if !col.filterable {
+ continue
+ }
+
+ value, ok := input.Row.Data[col.key]
+ if !ok {
+ continue
+ }
+
+ if sc, ok := value.(StyledCell); ok {
+ value = sc.Data
+ }
+
+ fmt.Fprint(&builder, value) // uses Stringer if implemented
+ builder.WriteByte(' ')
+ }
+
+ return strings.ToLower(builder.String())
+}
+
+func fuzzyTokenMatches(haystack, token string) bool {
+ if token[0] == '\'' && len(token) > 1 {
+ return strings.Contains(haystack, token[1:])
+ }
+
+ return fuzzySubsequenceMatch(haystack, token)
+}
+
+// fuzzySubsequenceMatch returns true if all runes in needle appear in order
+// within haystack (not necessarily contiguously). Case must be normalized by caller.
+func fuzzySubsequenceMatch(haystack, needle string) bool {
+ if needle == "" {
+ return true
+ }
+ haystackIndex, needleIndex := 0, 0
+ haystackRunes := []rune(haystack)
+ needleRunes := []rune(needle)
+
+ for haystackIndex < len(haystackRunes) && needleIndex < len(needleRunes) {
+ if haystackRunes[haystackIndex] == needleRunes[needleIndex] {
+ needleIndex++
+ }
+ haystackIndex++
+ }
+
+ return needleIndex == len(needleRunes)
+}
diff --git a/vendor/github.com/evertras/bubble-table/table/footer.go b/vendor/github.com/evertras/bubble-table/table/footer.go
index c68709ce4..a452630f9 100644
--- a/vendor/github.com/evertras/bubble-table/table/footer.go
+++ b/vendor/github.com/evertras/bubble-table/table/footer.go
@@ -6,7 +6,46 @@ import (
)
func (m Model) hasFooter() bool {
- return m.footerVisible && (m.staticFooter != "" || m.pageSize != 0 || m.filtered)
+ multiPageTargetHeight := m.targetHeight != 0 && m.pageStartIndices != nil && len(m.pageStartIndices) > 1
+
+ return m.footerVisible && (m.staticFooter != "" || m.pageSize != 0 || multiPageTargetHeight || m.filtered)
+}
+
+func (m Model) footerFilterSection() string {
+ if !m.filtered {
+ return ""
+ }
+
+ if m.filterTextInput.Focused() {
+ return m.filterTextInput.View()
+ }
+
+ if m.filterTextInput.Value() != "" {
+ // When not focused, show only the prompt + value without the
+ // cursor character that bubbles v2 renders in its View().
+ return m.filterTextInput.Prompt + m.filterTextInput.Value()
+ }
+
+ return ""
+}
+
+func (m Model) footerPageSection() string {
+ isPaged := m.pageSize != 0 || (m.targetHeight != 0 && m.pageStartIndices != nil && len(m.pageStartIndices) > 1)
+ if !isPaged {
+ return ""
+ }
+
+ str := fmt.Sprintf("%d/%d", m.CurrentPage(), m.MaxPages())
+
+ if m.filtered && m.filterTextInput.Focused() {
+ // Need to apply inline style here in case of filter input cursor, because
+ // the input cursor resets the style after rendering. Note that Inline(true)
+ // creates a copy, so it's safe to use here without mutating the underlying
+ // base style.
+ str = m.baseStyle.Inline(true).Render(str)
+ }
+
+ return str
}
func (m Model) renderFooter(width int, includeTop bool) string {
@@ -14,9 +53,11 @@ func (m Model) renderFooter(width int, includeTop bool) string {
return ""
}
- const borderAdjustment = 2
-
- styleFooter := m.baseStyle.Copy().Inherit(m.border.styleFooter).Width(width - borderAdjustment)
+ // In lipgloss v2, Width(n) sets the *total* outer width including borders.
+ // The footer style has left and right borders (overhead = 2) plus a bottom
+ // border. We pass the full row width directly so that content gets
+ // width-2 chars, matching the inner width of the data rows.
+ styleFooter := m.baseStyle.Inherit(m.border.styleFooter).Width(width)
if includeTop {
styleFooter = styleFooter.BorderTop(true)
@@ -28,24 +69,13 @@ func (m Model) renderFooter(width int, includeTop bool) string {
sections := []string{}
- if m.filtered && (m.filterTextInput.Focused() || m.filterTextInput.Value() != "") {
- sections = append(sections, m.filterTextInput.View())
+ if section := m.footerFilterSection(); section != "" {
+ sections = append(sections, section)
}
- // paged feature enabled
- if m.pageSize != 0 {
- str := fmt.Sprintf("%d/%d", m.CurrentPage(), m.MaxPages())
- if m.filtered && m.filterTextInput.Focused() {
- // Need to apply inline style here in case of filter input cursor, because
- // the input cursor resets the style after rendering. Note that Inline(true)
- // creates a copy, so it's safe to use here without mutating the underlying
- // base style.
- str = m.baseStyle.Inline(true).Render(str)
- }
- sections = append(sections, str)
+ if section := m.footerPageSection(); section != "" {
+ sections = append(sections, section)
}
- footerText := strings.Join(sections, " ")
-
- return styleFooter.Render(footerText)
+ return styleFooter.Render(strings.Join(sections, " "))
}
diff --git a/vendor/github.com/evertras/bubble-table/table/header.go b/vendor/github.com/evertras/bubble-table/table/header.go
index fdd5ac0bd..010844abb 100644
--- a/vendor/github.com/evertras/bubble-table/table/header.go
+++ b/vendor/github.com/evertras/bubble-table/table/header.go
@@ -1,6 +1,10 @@
package table
-import "github.com/charmbracelet/lipgloss"
+import (
+ "strings"
+
+ "charm.land/lipgloss/v2"
+)
// This is long and could use some refactoring in the future, but unsure of how
// to pick it apart right now.
@@ -9,16 +13,33 @@ import "github.com/charmbracelet/lipgloss"
func (m Model) renderHeaders() string {
headerStrings := []string{}
+ // Track column widths (content-only, not including border chars) so we can
+ // build the top border line and separator line as plain strings.
+ renderedColWidths := []int{}
+
totalRenderedWidth := 0
headerStyles := m.styleHeaders()
renderHeader := func(column Column, borderStyle lipgloss.Style) string {
- borderStyle = borderStyle.Inherit(column.style).Inherit(m.baseStyle)
+ // In lipgloss v2, Width(n) sets the *total* outer width including borders.
+ // Compute the actual border char overhead using the border size accessors so
+ // that any Width already set on borderStyle (e.g. from genOverflowStyle) does
+ // not pollute the overhead calculation.
+ borderOverhead := borderStyle.GetBorderLeftSize() + borderStyle.GetBorderRightSize()
+ style := borderStyle.Inherit(column.style).Inherit(m.baseStyle).Width(column.width + borderOverhead)
+
+ // lipgloss Inherit() explicitly skips padding/margin, so apply column
+ // padding directly to ensure it takes effect.
+ colPadTop, colPadRight, colPadBottom, colPadLeft := column.style.GetPadding()
+ if colPadTop != 0 || colPadRight != 0 || colPadBottom != 0 || colPadLeft != 0 {
+ style = style.Padding(colPadTop, colPadRight, colPadBottom, colPadLeft)
+ }
- headerSection := limitStr(column.title, column.width)
+ contentWidth := max(column.width-colPadLeft-colPadRight, 0)
+ headerSection := limitStr(column.title, contentWidth)
- return borderStyle.Render(headerSection)
+ return style.Render(headerSection)
}
for columnIndex, column := range m.columns {
@@ -26,16 +47,18 @@ func (m Model) renderHeaders() string {
if m.horizontalScrollOffsetCol > 0 && columnIndex == m.horizontalScrollFreezeColumnsCount {
if columnIndex == 0 {
- borderStyle = headerStyles.left.Copy()
+ borderStyle = headerStyles.left
} else {
- borderStyle = headerStyles.inner.Copy()
+ borderStyle = headerStyles.inner
}
- rendered := renderHeader(genOverflowColumnLeft(1), borderStyle)
+ overflowCol := genOverflowColumnLeft(1)
+ rendered := renderHeader(overflowCol, borderStyle)
totalRenderedWidth += lipgloss.Width(rendered)
headerStrings = append(headerStrings, rendered)
+ renderedColWidths = append(renderedColWidths, overflowCol.width)
}
if columnIndex >= m.horizontalScrollFreezeColumnsCount &&
@@ -44,11 +67,11 @@ func (m Model) renderHeaders() string {
}
if len(headerStrings) == 0 {
- borderStyle = headerStyles.left.Copy()
+ borderStyle = headerStyles.left
} else if columnIndex < len(m.columns)-1 {
- borderStyle = headerStyles.inner.Copy()
+ borderStyle = headerStyles.inner
} else {
- borderStyle = headerStyles.right.Copy()
+ borderStyle = headerStyles.right
}
rendered := renderHeader(column, borderStyle)
@@ -77,6 +100,7 @@ func (m Model) renderHeaders() string {
overflowStr := renderHeader(overflowColumn, overflowStyle)
headerStrings = append(headerStrings, overflowStr)
+ renderedColWidths = append(renderedColWidths, overflowColumn.width)
break
}
@@ -85,9 +109,37 @@ func (m Model) renderHeaders() string {
}
headerStrings = append(headerStrings, rendered)
+ renderedColWidths = append(renderedColWidths, column.width)
}
headerBlock := lipgloss.JoinHorizontal(lipgloss.Bottom, headerStrings...)
+ hasRows := len(m.GetVisibleRows()) > 0 || m.calculatePadding(0) > 0
+
+ return m.assembleHeaderOutput(headerBlock, renderedColWidths, hasRows)
+}
+
+func (m Model) assembleHeaderOutput(headerBlock string, renderedColWidths []int, hasRows bool) string {
+ if m.outerBorder {
+ var lastLine string
+ if hasRows {
+ lastLine = m.border.buildSeparatorLine(renderedColWidths)
+ } else {
+ lastLine = m.border.buildBottomBorderLine(renderedColWidths, m.hasFooter())
+ }
+ topLine := m.border.buildTopBorderLine(renderedColWidths)
+
+ return strings.Join([]string{topLine, headerBlock, lastLine}, "\n")
+ }
+
+ var lastLine string
+ if hasRows {
+ lastLine = m.border.buildInnerSeparatorLine(renderedColWidths)
+ }
+
+ if lastLine != "" {
+ return strings.Join([]string{headerBlock, lastLine}, "\n")
+ }
+
return headerBlock
}
diff --git a/vendor/github.com/evertras/bubble-table/table/keys.go b/vendor/github.com/evertras/bubble-table/table/keys.go
index fe2eccc38..490ab72cf 100644
--- a/vendor/github.com/evertras/bubble-table/table/keys.go
+++ b/vendor/github.com/evertras/bubble-table/table/keys.go
@@ -1,6 +1,6 @@
package table
-import "github.com/charmbracelet/bubbles/key"
+import "charm.land/bubbles/v2/key"
// KeyMap defines the keybindings for the table when it's focused.
type KeyMap struct {
@@ -42,7 +42,7 @@ func DefaultKeyMap() KeyMap {
key.WithHelp("↑/k", "move up"),
),
RowSelectToggle: key.NewBinding(
- key.WithKeys(" ", "enter"),
+ key.WithKeys("space", "enter"),
key.WithHelp("/enter", "select row"),
),
PageDown: key.NewBinding(
diff --git a/vendor/github.com/evertras/bubble-table/table/model.go b/vendor/github.com/evertras/bubble-table/table/model.go
index d39b6604c..efdd90127 100644
--- a/vendor/github.com/evertras/bubble-table/table/model.go
+++ b/vendor/github.com/evertras/bubble-table/table/model.go
@@ -1,10 +1,10 @@
package table
import (
- "github.com/charmbracelet/bubbles/key"
- "github.com/charmbracelet/bubbles/textinput"
- tea "github.com/charmbracelet/bubbletea"
- "github.com/charmbracelet/lipgloss"
+ "charm.land/bubbles/v2/key"
+ "charm.land/bubbles/v2/textinput"
+ tea "charm.land/bubbletea/v2"
+ "charm.land/lipgloss/v2"
)
const (
@@ -12,21 +12,26 @@ const (
)
var (
- defaultHighlightStyle = lipgloss.NewStyle().Background(lipgloss.Color("#334"))
+ // defaultHighlightStyle has no visual effect; users opt into highlight colors
+ // via WithHighlightStyle. This matches the historical rendering behavior
+ // where the table background color was not automatically applied to focused
+ // rows.
+ defaultHighlightStyle = lipgloss.NewStyle()
)
// Model is the main table model. Create using New().
type Model struct {
// Data
- columns []Column
- rows []Row
+ columns []Column
+ rows []Row
+ metadata map[string]any
// Caches for optimizations
visibleRowCacheUpdated bool
visibleRowCache []Row
// Shown when data is missing from a row
- missingDataIndicator interface{}
+ missingDataIndicator any
// Interaction
focused bool
@@ -78,6 +83,7 @@ type Model struct {
// Filter
filtered bool
filterTextInput textinput.Model
+ filterFunc FilterFunc
// For flex columns
targetTotalWidth int
@@ -101,22 +107,49 @@ type Model struct {
// Minimum total height of the table
minimumHeight int
+ // Target total height of the table in terminal lines, including borders,
+ // header, and footer. When set, the table fits as many rows as possible
+ // per page. Mutually exclusive with pageSize.
+ targetHeight int
+
+ // Cached page boundary indices when targetHeight is set.
+ // pageStartIndices[i] is the index of the first visible row on page i.
+ // Nil means the cache needs rebuilding.
+ pageStartIndices []int
+
// Internal cached calculation, the height of the header and footer
// including borders. Used to determine how many padding rows to add.
metaHeight int
// If true, the table will be multiline
multiline bool
+
+ // If true, draw a horizontal separator line between each data row
+ rowSeparator bool
+
+ // If true, render the outer border (top line, bottom line, left/right cell borders)
+ outerBorder bool
}
// New creates a new table ready for further modifications.
func New(columns []Column) Model {
filterInput := textinput.New()
filterInput.Prompt = "/"
+ // Use plain styles without foreground colors so that the filter text
+ // renders without ANSI color codes, keeping the output predictable.
+ plainStyles := textinput.DefaultDarkStyles()
+ plainStyles.Focused.Prompt = lipgloss.NewStyle()
+ plainStyles.Focused.Text = lipgloss.NewStyle()
+ plainStyles.Blurred.Prompt = lipgloss.NewStyle()
+ plainStyles.Blurred.Text = lipgloss.NewStyle()
+ plainStyles.Cursor.Color = lipgloss.NoColor{}
+ filterInput.SetStyles(plainStyles)
model := Model{
columns: make([]Column, len(columns)),
- highlightStyle: defaultHighlightStyle.Copy(),
+ metadata: make(map[string]any),
+ highlightStyle: defaultHighlightStyle,
border: borderDefault,
+ outerBorder: true,
headerVisible: true,
footerVisible: true,
keyMap: DefaultKeyMap(),
@@ -125,6 +158,7 @@ func New(columns []Column) Model {
unselectedText: "[ ]",
filterTextInput: filterInput,
+ filterFunc: filterFuncContains,
baseStyle: lipgloss.NewStyle().Align(lipgloss.Right),
paginationWrapping: true,
diff --git a/vendor/github.com/evertras/bubble-table/table/options.go b/vendor/github.com/evertras/bubble-table/table/options.go
index 95119549f..1a44118bd 100644
--- a/vendor/github.com/evertras/bubble-table/table/options.go
+++ b/vendor/github.com/evertras/bubble-table/table/options.go
@@ -1,9 +1,12 @@
package table
import (
- "github.com/charmbracelet/bubbles/key"
- "github.com/charmbracelet/bubbles/textinput"
- "github.com/charmbracelet/lipgloss"
+ "image/color"
+
+ "charm.land/bubbles/v2/key"
+ "charm.land/bubbles/v2/textinput"
+ "charm.land/lipgloss/v2"
+ "github.com/charmbracelet/x/ansi"
)
// RowStyleFuncInput is the input to the style function that can
@@ -53,7 +56,7 @@ func (m Model) WithHighlightedRow(index int) Model {
// HeaderStyle sets the style to apply to the header text, such as color or bold.
func (m Model) HeaderStyle(style lipgloss.Style) Model {
- m.headerStyle = style.Copy()
+ m.headerStyle = style
return m
}
@@ -71,7 +74,16 @@ func (m Model) WithRows(rows []Row) Model {
m.rowCursorIndex = 0
}
- if m.pageSize != 0 {
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ m.ensurePageMap()
+
+ maxPage := m.MaxPages()
+
+ if maxPage <= m.currentPage {
+ m.pageLast()
+ }
+ } else if m.pageSize != 0 {
maxPage := m.MaxPages()
// MaxPages is 1-index, currentPage is 0 index
@@ -104,8 +116,9 @@ func (m Model) SelectableRows(selectable bool) Model {
if hasSelectColumn != selectable {
if selectable {
+ selectColWidth := max(ansi.StringWidth(m.selectedText), ansi.StringWidth(m.unselectedText))
m.columns = append([]Column{
- NewColumn(columnKeySelect, m.selectedText, len([]rune(m.selectedText))),
+ NewColumn(columnKeySelect, m.selectedText, selectColWidth),
}, m.columns...)
} else {
m.columns = m.columns[1:]
@@ -162,10 +175,14 @@ func (m Model) Filtered(filtered bool) Model {
m.filtered = filtered
m.visibleRowCacheUpdated = false
- if m.minimumHeight > 0 {
+ if m.minimumHeight > 0 || m.targetHeight != 0 {
m.recalculateHeight()
}
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -180,10 +197,14 @@ func (m Model) StartFilterTyping() Model {
func (m Model) WithStaticFooter(footer string) Model {
m.staticFooter = footer
- if m.minimumHeight > 0 {
+ if m.minimumHeight > 0 || m.targetHeight != 0 {
m.recalculateHeight()
}
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -231,7 +252,8 @@ func (m Model) WithSelectedText(unselected, selected string) Model {
m.unselectedText = unselected
if len(m.columns) > 0 && m.columns[0].key == columnKeySelect {
- m.columns[0] = NewColumn(columnKeySelect, m.selectedText, len([]rune(m.selectedText)))
+ selectColWidth := max(ansi.StringWidth(m.selectedText), ansi.StringWidth(m.unselectedText))
+ m.columns[0] = NewColumn(columnKeySelect, m.selectedText, selectColWidth)
m.recalculateWidth()
}
@@ -246,6 +268,36 @@ func (m Model) WithBaseStyle(style lipgloss.Style) Model {
return m
}
+// WithBorderForeground sets the foreground colour for the plain-string
+// horizontal border lines (top border, header/data separator, bottom border).
+// The left and right cell border characters are coloured via WithBaseStyle;
+// this option covers the horizontal lines that are rendered as plain strings.
+func (m Model) WithBorderForeground(c color.Color) Model {
+ m.border.foreground = c
+
+ return m
+}
+
+// WithOuterBorder controls whether the outer border of the table is rendered
+// (top line, bottom line, and left/right cell borders). Defaults to true.
+func (m Model) WithOuterBorder(show bool) Model {
+ m.outerBorder = show
+
+ return m
+}
+
+// WithRowBorder controls whether a horizontal separator line is drawn between
+// each pair of data rows, creating a grid-like appearance.
+func (m Model) WithRowBorder(show bool) Model {
+ m.rowSeparator = show
+
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
+ return m
+}
+
// WithTargetWidth sets the total target width of the table, including borders.
// This only takes effect when using flex columns. When using flex columns,
// columns will stretch to fill out to the total width given here.
@@ -254,6 +306,10 @@ func (m Model) WithTargetWidth(totalWidth int) Model {
m.recalculateWidth()
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -266,6 +322,20 @@ func (m Model) WithMinimumHeight(minimumHeight int) Model {
return m
}
+// WithTargetHeight sets the total target height of the table in terminal lines,
+// including borders, header, and footer. The table automatically fits as many
+// rows as possible within that height per page, with proper pagination for the
+// remainder. This is the correct way to constrain table height when
+// WithMultiline is enabled. Mutually exclusive with WithPageSize.
+func (m Model) WithTargetHeight(height int) Model {
+ m.targetHeight = height
+ m.pageSize = 0
+ m.pageStartIndices = nil
+ m.ensurePageMap()
+
+ return m
+}
+
// PageDown goes to the next page of a paginated table, wrapping to the first
// page if the table is already on the last page.
func (m Model) PageDown() Model {
@@ -300,6 +370,26 @@ func (m Model) PageFirst() Model {
// table, bounded to the total number of pages. The current selected row will
// be set to the top row of the page if the page changed.
func (m Model) WithCurrentPage(currentPage int) Model {
+ if m.targetHeight != 0 {
+ m.ensurePageMap()
+
+ maxPages := m.MaxPages()
+
+ if currentPage < 1 {
+ currentPage = 1
+ } else if currentPage > maxPages {
+ currentPage = maxPages
+ }
+
+ m.currentPage = currentPage - 1
+
+ if m.currentPage < len(m.pageStartIndices) {
+ m.rowCursorIndex = m.pageStartIndices[m.currentPage]
+ }
+
+ return m
+ }
+
if m.pageSize == 0 || currentPage == m.CurrentPage() {
return m
}
@@ -332,6 +422,10 @@ func (m Model) WithColumns(columns []Column) Model {
m = m.SelectableRows(true)
}
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -346,6 +440,10 @@ func (m Model) WithFilterInput(input textinput.Model) Model {
m.filterTextInput = input
m.visibleRowCacheUpdated = false
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -361,17 +459,42 @@ func (m Model) WithFilterInputValue(value string) Model {
m.filterTextInput.Blur()
m.visibleRowCacheUpdated = false
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
+ return m
+}
+
+// WithFilterFunc adds a filter function to the model. If the function returns
+// true, the row will be included in the filtered results. If the function
+// is nil, the function won't be used and instead the default filtering will be applied,
+// if any.
+func (m Model) WithFilterFunc(shouldInclude FilterFunc) Model {
+ m.filterFunc = shouldInclude
+
+ m.visibleRowCacheUpdated = false
+
return m
}
+// WithFuzzyFilter enables fuzzy filtering for the table.
+func (m Model) WithFuzzyFilter() Model {
+ return m.WithFilterFunc(filterFuncFuzzy)
+}
+
// WithFooterVisibility sets the visibility of the footer.
func (m Model) WithFooterVisibility(visibility bool) Model {
m.footerVisible = visibility
- if m.minimumHeight > 0 {
+ if m.minimumHeight > 0 || m.targetHeight != 0 {
m.recalculateHeight()
}
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -379,10 +502,14 @@ func (m Model) WithFooterVisibility(visibility bool) Model {
func (m Model) WithHeaderVisibility(visibility bool) Model {
m.headerVisible = visibility
- if m.minimumHeight > 0 {
+ if m.minimumHeight > 0 || m.targetHeight != 0 {
m.recalculateHeight()
}
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -462,6 +589,10 @@ func (m Model) WithAllRowsDeselected() Model {
func (m Model) WithMultiline(multiline bool) Model {
m.multiline = multiline
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m
}
@@ -482,3 +613,12 @@ func (m Model) WithAdditionalFullHelpKeys(keys []key.Binding) Model {
return m
}
+
+// WithGlobalMetadata applies the given metadata to the table. This metadata is passed to
+// some functions in FilterFuncInput and StyleFuncInput to enable more advanced decisions,
+// such as setting some global theme variable to reference, etc. Has no effect otherwise.
+func (m Model) WithGlobalMetadata(metadata map[string]any) Model {
+ m.metadata = metadata
+
+ return m
+}
diff --git a/vendor/github.com/evertras/bubble-table/table/overflow.go b/vendor/github.com/evertras/bubble-table/table/overflow.go
index 19c5b0aa4..5776be1b8 100644
--- a/vendor/github.com/evertras/bubble-table/table/overflow.go
+++ b/vendor/github.com/evertras/bubble-table/table/overflow.go
@@ -1,6 +1,6 @@
package table
-import "github.com/charmbracelet/lipgloss"
+import "charm.land/lipgloss/v2"
const columnKeyOverflowRight = "___overflow_r___"
const columnKeyOverflowLeft = "___overflow_l__"
diff --git a/vendor/github.com/evertras/bubble-table/table/pagination.go b/vendor/github.com/evertras/bubble-table/table/pagination.go
index 6fce9b519..d2ce0f5ac 100644
--- a/vendor/github.com/evertras/bubble-table/table/pagination.go
+++ b/vendor/github.com/evertras/bubble-table/table/pagination.go
@@ -14,6 +14,16 @@ func (m *Model) CurrentPage() int {
// MaxPages returns the maximum number of pages that are visible.
func (m *Model) MaxPages() int {
+ if m.targetHeight != 0 {
+ m.ensurePageMap()
+
+ if len(m.pageStartIndices) == 0 {
+ return 1
+ }
+
+ return len(m.pageStartIndices)
+ }
+
totalRows := len(m.GetVisibleRows())
if m.pageSize == 0 || totalRows == 0 {
@@ -34,6 +44,24 @@ func (m *Model) TotalRows() int {
func (m *Model) VisibleIndices() (start, end int) {
totalRows := len(m.GetVisibleRows())
+ if m.targetHeight != 0 {
+ m.ensurePageMap()
+
+ if totalRows == 0 || len(m.pageStartIndices) == 0 {
+ return 0, -1
+ }
+
+ start = m.pageStartIndices[m.currentPage]
+
+ if m.currentPage+1 < len(m.pageStartIndices) {
+ end = m.pageStartIndices[m.currentPage+1] - 1
+ } else {
+ end = totalRows - 1
+ }
+
+ return start, end
+ }
+
if m.pageSize == 0 {
start = 0
end = totalRows - 1
@@ -51,43 +79,75 @@ func (m *Model) VisibleIndices() (start, end int) {
return start, end
}
-func (m *Model) pageDown() {
- if m.pageSize == 0 || len(m.GetVisibleRows()) <= m.pageSize {
+func (m *Model) wrappedOrClamped(wrappedValue, clampedValue int) int {
+ if m.paginationWrapping {
+ return wrappedValue
+ }
+
+ return clampedValue
+}
+
+func (m *Model) clampCurrentPage(maxPageIndex int) {
+ if m.currentPage > maxPageIndex {
+ m.currentPage = m.wrappedOrClamped(0, maxPageIndex)
+ } else if m.currentPage < 0 {
+ m.currentPage = m.wrappedOrClamped(maxPageIndex, 0)
+ }
+}
+
+func (m *Model) pageDownTargetHeight() {
+ m.ensurePageMap()
+
+ if len(m.pageStartIndices) <= 1 {
return
}
m.currentPage++
+ m.clampCurrentPage(len(m.pageStartIndices) - 1)
+ m.rowCursorIndex = m.pageStartIndices[m.currentPage]
+}
- maxPageIndex := m.MaxPages() - 1
+func (m *Model) pageUpTargetHeight() {
+ m.ensurePageMap()
- if m.currentPage > maxPageIndex {
- if m.paginationWrapping {
- m.currentPage = 0
- } else {
- m.currentPage = maxPageIndex
- }
+ if len(m.pageStartIndices) <= 1 {
+ return
}
- m.rowCursorIndex = m.currentPage * m.pageSize
+ m.currentPage--
+ m.clampCurrentPage(len(m.pageStartIndices) - 1)
+ m.rowCursorIndex = m.pageStartIndices[m.currentPage]
}
-func (m *Model) pageUp() {
+func (m *Model) pageDown() {
+ if m.targetHeight != 0 {
+ m.pageDownTargetHeight()
+
+ return
+ }
+
if m.pageSize == 0 || len(m.GetVisibleRows()) <= m.pageSize {
return
}
- m.currentPage--
+ m.currentPage++
+ m.clampCurrentPage(m.MaxPages() - 1)
+ m.rowCursorIndex = m.currentPage * m.pageSize
+}
- maxPageIndex := m.MaxPages() - 1
+func (m *Model) pageUp() {
+ if m.targetHeight != 0 {
+ m.pageUpTargetHeight()
- if m.currentPage < 0 {
- if m.paginationWrapping {
- m.currentPage = maxPageIndex
- } else {
- m.currentPage = 0
- }
+ return
+ }
+
+ if m.pageSize == 0 || len(m.GetVisibleRows()) <= m.pageSize {
+ return
}
+ m.currentPage--
+ m.clampCurrentPage(m.MaxPages() - 1)
m.rowCursorIndex = m.currentPage * m.pageSize
}
@@ -97,16 +157,45 @@ func (m *Model) pageFirst() {
}
func (m *Model) pageLast() {
+ if m.targetHeight != 0 {
+ m.ensurePageMap()
+
+ if len(m.pageStartIndices) == 0 {
+ return
+ }
+
+ m.currentPage = len(m.pageStartIndices) - 1
+ m.rowCursorIndex = m.pageStartIndices[m.currentPage]
+
+ return
+ }
+
m.currentPage = m.MaxPages() - 1
m.rowCursorIndex = m.currentPage * m.pageSize
}
func (m *Model) expectedPageForRowIndex(rowIndex int) int {
+ if m.targetHeight != 0 {
+ m.ensurePageMap()
+
+ // Binary search: find the last page whose start index <= rowIndex.
+ low, high := 0, len(m.pageStartIndices)-1
+
+ for low < high {
+ mid := (low + high + 1) / 2 //nolint:mnd // standard ceiling-midpoint formula
+ if m.pageStartIndices[mid] <= rowIndex {
+ low = mid
+ } else {
+ high = mid - 1
+ }
+ }
+
+ return low
+ }
+
if m.pageSize == 0 {
return 0
}
- expectedPage := rowIndex / m.pageSize
-
- return expectedPage
+ return rowIndex / m.pageSize
}
diff --git a/vendor/github.com/evertras/bubble-table/table/row.go b/vendor/github.com/evertras/bubble-table/table/row.go
index 2ba451973..f672abafb 100644
--- a/vendor/github.com/evertras/bubble-table/table/row.go
+++ b/vendor/github.com/evertras/bubble-table/table/row.go
@@ -4,16 +4,16 @@ import (
"fmt"
"sync/atomic"
- "github.com/charmbracelet/lipgloss"
- "github.com/muesli/reflow/wordwrap"
+ "charm.land/lipgloss/v2"
+ "github.com/charmbracelet/x/ansi"
)
-// RowData is a map of string column keys to interface{} data. Data with a key
+// RowData is a map of string column keys to arbitrary data. Data with a key
// that matches a column key will be displayed. Data with a key that does not
// match a column key will not be displayed, but will remain attached to the Row.
// This can be useful for attaching hidden metadata for future reference when
// retrieving rows.
-type RowData map[string]interface{}
+type RowData map[string]any
// Row represents a row in the table with some data keyed to the table columns>
// Can have a style applied to it such as color/bold. Create using NewRow().
@@ -32,7 +32,7 @@ var lastRowID uint32 = 1
// NewRow creates a new row and copies the given row data.
func NewRow(data RowData) Row {
row := Row{
- Data: make(map[string]interface{}),
+ Data: make(map[string]any),
id: lastRowID,
}
@@ -48,32 +48,57 @@ func NewRow(data RowData) Row {
// WithStyle uses the given style for the text in the row.
func (r Row) WithStyle(style lipgloss.Style) Row {
- r.Style = style.Copy()
+ r.Style = style
return r
}
-//nolint:nestif,cyclop // This has many ifs, but they're short
+// rowLineCount returns the number of terminal lines the row occupies when rendered.
+// For non-multiline tables this is always 1.
+func (m *Model) rowLineCount(row Row) int {
+ if !m.multiline {
+ return 1
+ }
+
+ maxLines := 1
+
+ for _, column := range m.columns {
+ cellStr := m.renderRowColumnData(row, column, row.Style, lipgloss.NewStyle())
+ maxLines = max(maxLines, lipgloss.Height(cellStr))
+ }
+
+ return maxLines
+}
+
+//nolint:cyclop,funlen // Breaking this up will be more complicated than it's worth for now
func (m Model) renderRowColumnData(row Row, column Column, rowStyle lipgloss.Style, borderStyle lipgloss.Style) string {
- cellStyle := rowStyle.Copy().Inherit(column.style).Inherit(m.baseStyle)
+ cellStyle := rowStyle.Inherit(column.style).Inherit(m.baseStyle)
+
+ // lipgloss Inherit() explicitly skips padding/margin, so apply column
+ // padding directly to ensure it takes effect.
+ colPadTop, colPadRight, colPadBottom, colPadLeft := column.style.GetPadding()
+ if colPadTop != 0 || colPadRight != 0 || colPadBottom != 0 || colPadLeft != 0 {
+ cellStyle = cellStyle.Padding(colPadTop, colPadRight, colPadBottom, colPadLeft)
+ }
var str string
- if column.key == columnKeySelect {
+ switch column.key {
+ case columnKeySelect:
if row.selected {
str = m.selectedText
} else {
str = m.unselectedText
}
- } else if column.key == columnKeyOverflowRight {
+ case columnKeyOverflowRight:
cellStyle = cellStyle.Align(lipgloss.Right)
str = ">"
- } else if column.key == columnKeyOverflowLeft {
+ case columnKeyOverflowLeft:
str = "<"
- } else {
+ default:
fmtString := "%v"
- var data interface{}
+ var data any
if entry, exists := row.Data[column.key]; exists {
data = entry
@@ -90,30 +115,52 @@ func (m Model) renderRowColumnData(row Row, column Column, rowStyle lipgloss.Sty
switch entry := data.(type) {
case StyledCell:
str = fmt.Sprintf(fmtString, entry.Data)
- cellStyle = entry.Style.Copy().Inherit(cellStyle)
+
+ if entry.StyleFunc != nil {
+ cellStyle = entry.StyleFunc(StyledCellFuncInput{
+ Column: column,
+ Data: entry.Data,
+ Row: row,
+ GlobalMetadata: m.metadata,
+ }).Inherit(cellStyle)
+ } else {
+ cellStyle = entry.Style.Inherit(cellStyle)
+ }
default:
str = fmt.Sprintf(fmtString, entry)
}
}
+ // Reduce the available text width by any horizontal column padding so that
+ // content is truncated/wrapped to the inner content area, not the full cell.
+ contentWidth := max(column.width-colPadLeft-colPadRight, 0)
+
if m.multiline {
- str = wordwrap.String(str, column.width)
+ str = ansi.Wordwrap(str, contentWidth, "")
+ // a bug in Wordwrap means when hyphens are used as a breakpoint, the wrap is done AFTER the hyphen
+ // resulting in a line that exceeds the column width
+ // Hardwrap as a seconds step avoids this
+ str = ansi.Hardwrap(str, contentWidth, false)
cellStyle = cellStyle.Align(lipgloss.Top)
} else {
- str = limitStr(str, column.width)
+ str = limitStr(str, contentWidth)
}
- cellStyle = cellStyle.Inherit(borderStyle)
+ // In lipgloss v2, Width() sets the *total* outer width (including borders).
+ // Use the border size accessors so that any Width already set on borderStyle
+ // (e.g. from genOverflowStyle) does not pollute the overhead calculation.
+ borderOverhead := borderStyle.GetBorderLeftSize() + borderStyle.GetBorderRightSize()
+ cellStyle = cellStyle.Inherit(borderStyle).Width(column.width + borderOverhead)
cellStr := cellStyle.Render(str)
return cellStr
}
-func (m Model) renderRow(rowIndex int, last bool) string {
+func (m Model) renderRow(rowIndex int, last bool, separatorBelow bool) string {
row := m.GetVisibleRows()[rowIndex]
highlighted := rowIndex == m.rowCursorIndex
- rowStyle := row.Style.Copy()
+ rowStyle := row.Style
if m.rowStyleFunc != nil {
styleResult := m.rowStyleFunc(RowStyleFuncInput{
@@ -127,21 +174,23 @@ func (m Model) renderRow(rowIndex int, last bool) string {
rowStyle = rowStyle.Inherit(m.highlightStyle)
}
- return m.renderRowData(row, rowStyle, last)
+ return m.renderRowData(row, rowStyle, last, separatorBelow)
}
func (m Model) renderBlankRow(last bool) string {
- return m.renderRowData(NewRow(nil), lipgloss.NewStyle(), last)
+ return m.renderRowData(NewRow(nil), lipgloss.NewStyle(), last, false)
}
// This is long and could use some refactoring in the future, but not quite sure
// how to pick it apart yet.
//
-//nolint:funlen, cyclop, gocognit
-func (m Model) renderRowData(row Row, rowStyle lipgloss.Style, last bool) string {
+//nolint:funlen, cyclop
+func (m Model) renderRowData(row Row, rowStyle lipgloss.Style, last bool, separatorBelow bool) string {
numColumns := len(m.columns)
columnStrings := []string{}
+ // Track content-only column widths for building the bottom border line.
+ renderedColWidths := []int{}
totalRenderedWidth := 0
stylesInner, stylesLast := m.styleRows()
@@ -154,31 +203,32 @@ func (m Model) renderRowData(row Row, rowStyle lipgloss.Style, last bool) string
}
}
+ // We always use the "inner" styles for cell borders; the bottom border line
+ // is rendered as a plain string below when last==true.
+ rowStyles := stylesInner
+ _ = stylesLast // kept for potential future use
+
for columnIndex, column := range m.columns {
var borderStyle lipgloss.Style
- var rowStyles borderStyleRow
- if !last {
- rowStyles = stylesInner
- } else {
- rowStyles = stylesLast
- }
- rowStyle = rowStyle.Copy().Height(maxCellHeight)
+ rowStyle = rowStyle.Height(maxCellHeight)
if m.horizontalScrollOffsetCol > 0 && columnIndex == m.horizontalScrollFreezeColumnsCount {
var borderStyle lipgloss.Style
if columnIndex == 0 {
- borderStyle = rowStyles.left.Copy()
+ borderStyle = rowStyles.left
} else {
- borderStyle = rowStyles.inner.Copy()
+ borderStyle = rowStyles.inner
}
- rendered := m.renderRowColumnData(row, genOverflowColumnLeft(1), rowStyle, borderStyle)
+ overflowCol := genOverflowColumnLeft(1)
+ rendered := m.renderRowColumnData(row, overflowCol, rowStyle, borderStyle)
totalRenderedWidth += lipgloss.Width(rendered)
columnStrings = append(columnStrings, rendered)
+ renderedColWidths = append(renderedColWidths, overflowCol.width)
}
if columnIndex >= m.horizontalScrollFreezeColumnsCount &&
@@ -219,6 +269,7 @@ func (m Model) renderRowData(row Row, rowStyle lipgloss.Style, last bool) string
overflowStr := m.renderRowColumnData(row, overflowColumn, rowStyle, overflowStyle)
columnStrings = append(columnStrings, overflowStr)
+ renderedColWidths = append(renderedColWidths, overflowColumn.width)
break
}
@@ -227,9 +278,37 @@ func (m Model) renderRowData(row Row, rowStyle lipgloss.Style, last bool) string
}
columnStrings = append(columnStrings, cellStr)
+ renderedColWidths = append(renderedColWidths, column.width)
+ }
+
+ rowLine := lipgloss.JoinHorizontal(lipgloss.Bottom, columnStrings...)
+
+ return m.assembleRowOutput(rowLine, renderedColWidths, last, separatorBelow)
+}
+
+func (m Model) assembleRowOutput(rowLine string, renderedColWidths []int, last, separatorBelow bool) string {
+ if last {
+ if m.outerBorder {
+ bottomLine := m.border.buildBottomBorderLine(renderedColWidths, m.hasFooter())
+
+ return rowLine + "\n" + bottomLine
+ }
+
+ return rowLine
+ }
+
+ if separatorBelow {
+ var sepLine string
+ if m.outerBorder {
+ sepLine = m.border.buildSeparatorLine(renderedColWidths)
+ } else {
+ sepLine = m.border.buildInnerSeparatorLine(renderedColWidths)
+ }
+
+ return rowLine + "\n" + sepLine
}
- return lipgloss.JoinHorizontal(lipgloss.Bottom, columnStrings...)
+ return rowLine
}
// Selected returns a copy of the row that's set to be selected or deselected.
diff --git a/vendor/github.com/evertras/bubble-table/table/sort.go b/vendor/github.com/evertras/bubble-table/table/sort.go
index 9a282cbda..44a18ab2c 100644
--- a/vendor/github.com/evertras/bubble-table/table/sort.go
+++ b/vendor/github.com/evertras/bubble-table/table/sort.go
@@ -3,6 +3,7 @@ package table
import (
"fmt"
"sort"
+ "time"
)
// SortDirection indicates whether a column should sort by ascending or descending.
@@ -130,6 +131,16 @@ func (s *sortableTable) extractNumber(i int, column string) (float64, bool) {
return asNumber(iData)
}
+func (s *sortableTable) extractTime(i int, column string) (time.Time, bool) {
+ iData, exists := s.rows[i].Data[column]
+
+ if !exists {
+ return time.Time{}, false
+ }
+
+ return asTime(iData)
+}
+
func (s *sortableTable) Less(first, second int) bool {
firstNum, firstNumIsValid := s.extractNumber(first, s.byColumn.ColumnKey)
secondNum, secondNumIsValid := s.extractNumber(second, s.byColumn.ColumnKey)
@@ -142,6 +153,17 @@ func (s *sortableTable) Less(first, second int) bool {
return firstNum > secondNum
}
+ firstTime, firstTimeIsValid := s.extractTime(first, s.byColumn.ColumnKey)
+ secondTime, secondTimeIsValid := s.extractTime(second, s.byColumn.ColumnKey)
+
+ if firstTimeIsValid && secondTimeIsValid {
+ if s.byColumn.Direction == SortDirectionAsc {
+ return firstTime.Before(secondTime)
+ }
+
+ return secondTime.Before(firstTime)
+ }
+
firstVal := s.extractString(first, s.byColumn.ColumnKey)
secondVal := s.extractString(second, s.byColumn.ColumnKey)
diff --git a/vendor/github.com/evertras/bubble-table/table/strlimit.go b/vendor/github.com/evertras/bubble-table/table/strlimit.go
index 1b656625e..dc2ff9db0 100644
--- a/vendor/github.com/evertras/bubble-table/table/strlimit.go
+++ b/vendor/github.com/evertras/bubble-table/table/strlimit.go
@@ -3,8 +3,7 @@ package table
import (
"strings"
- "github.com/muesli/reflow/ansi"
- "github.com/muesli/reflow/truncate"
+ "github.com/charmbracelet/x/ansi"
)
func limitStr(str string, maxLen int) string {
@@ -17,8 +16,8 @@ func limitStr(str string, maxLen int) string {
str = str[:newLineIndex] + "…"
}
- if ansi.PrintableRuneWidth(str) > maxLen {
- return truncate.StringWithTail(str, uint(maxLen), "…")
+ if ansi.StringWidth(str) > maxLen {
+ return ansi.Truncate(str, maxLen, "…")
}
return str
diff --git a/vendor/github.com/evertras/bubble-table/table/update.go b/vendor/github.com/evertras/bubble-table/table/update.go
index 198a57d2c..3ef8e0509 100644
--- a/vendor/github.com/evertras/bubble-table/table/update.go
+++ b/vendor/github.com/evertras/bubble-table/table/update.go
@@ -1,8 +1,8 @@
package table
import (
- "github.com/charmbracelet/bubbles/key"
- tea "github.com/charmbracelet/bubbletea"
+ "charm.land/bubbles/v2/key"
+ tea "charm.land/bubbletea/v2"
)
func (m *Model) moveHighlightUp() {
@@ -54,7 +54,7 @@ func (m *Model) toggleSelect() {
func (m Model) updateFilterTextInput(msg tea.Msg) (Model, tea.Cmd) {
var cmd tea.Cmd
switch msg := msg.(type) {
- case tea.KeyMsg:
+ case tea.KeyPressMsg:
if key.Matches(msg, m.keyMap.FilterBlur) {
m.filterTextInput.Blur()
}
@@ -63,13 +63,17 @@ func (m Model) updateFilterTextInput(msg tea.Msg) (Model, tea.Cmd) {
m.pageFirst()
m.visibleRowCacheUpdated = false
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
+
return m, cmd
}
// This is a series of Matches tests with minimal logic
//
//nolint:cyclop
-func (m *Model) handleKeypress(msg tea.KeyMsg) {
+func (m *Model) handleKeypress(msg tea.KeyPressMsg) {
previousRowIndex := m.rowCursorIndex
if key.Matches(msg, m.keyMap.RowDown) {
@@ -108,6 +112,10 @@ func (m *Model) handleKeypress(msg tea.KeyMsg) {
if key.Matches(msg, m.keyMap.FilterClear) {
m.visibleRowCacheUpdated = false
m.filterTextInput.Reset()
+
+ if m.targetHeight != 0 {
+ m.pageStartIndices = nil
+ }
}
if key.Matches(msg, m.keyMap.ScrollRight) {
@@ -146,7 +154,7 @@ func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
}
switch msg := msg.(type) {
- case tea.KeyMsg:
+ case tea.KeyPressMsg:
m.handleKeypress(msg)
}
diff --git a/vendor/github.com/evertras/bubble-table/table/view.go b/vendor/github.com/evertras/bubble-table/table/view.go
index 5ef545cb9..45692973b 100644
--- a/vendor/github.com/evertras/bubble-table/table/view.go
+++ b/vendor/github.com/evertras/bubble-table/table/view.go
@@ -3,9 +3,42 @@ package table
import (
"strings"
- "github.com/charmbracelet/lipgloss"
+ "charm.land/lipgloss/v2"
)
+// visibleDataLines returns the total terminal lines occupied by visible rows in
+// the range [startRowIndex, endRowIndex], including any separator lines between
+// rows when WithRowBorder is active.
+func (m *Model) visibleDataLines(startRowIndex, endRowIndex int) int {
+ numRows := endRowIndex - startRowIndex + 1
+
+ if numRows <= 0 {
+ return numRows
+ }
+
+ if !m.multiline {
+ if m.rowSeparator {
+ // Each pair of adjacent rows has one separator line between them.
+ return 2*numRows - 1
+ }
+
+ return numRows
+ }
+
+ total := 0
+ visibleRows := m.GetVisibleRows()
+
+ for rowIdx := startRowIndex; rowIdx <= endRowIndex; rowIdx++ {
+ total += m.rowLineCount(visibleRows[rowIdx])
+
+ if m.rowSeparator && rowIdx > startRowIndex {
+ total++
+ }
+ }
+
+ return total
+}
+
// View renders the table. It does not end in a newline, so that it can be
// composed with other elements more consistently.
//
@@ -23,20 +56,23 @@ func (m Model) View() string {
headers := m.renderHeaders()
startRowIndex, endRowIndex := m.VisibleIndices()
- numRows := endRowIndex - startRowIndex + 1
- padding := m.calculatePadding(numRows)
+ padding := m.calculatePadding(m.visibleDataLines(startRowIndex, endRowIndex))
+
+ numRows := endRowIndex - startRowIndex + 1
if m.headerVisible {
rowStrs = append(rowStrs, headers)
} else if numRows > 0 || padding > 0 {
- //nolint: gomnd // This is just getting the first newlined substring
+ //nolint: mnd // This is just getting the first newlined substring
split := strings.SplitN(headers, "\n", 2)
rowStrs = append(rowStrs, split[0])
}
for i := startRowIndex; i <= endRowIndex; i++ {
- rowStrs = append(rowStrs, m.renderRow(i, padding == 0 && i == endRowIndex))
+ isLast := padding == 0 && i == endRowIndex
+ separatorBelow := m.rowSeparator && i < endRowIndex
+ rowStrs = append(rowStrs, m.renderRow(i, isLast, separatorBelow))
}
for i := 1; i <= padding; i++ {
diff --git a/vendor/github.com/muesli/reflow/ansi/ansi.go b/vendor/github.com/muesli/reflow/ansi/ansi.go
deleted file mode 100644
index f3d0700af..000000000
--- a/vendor/github.com/muesli/reflow/ansi/ansi.go
+++ /dev/null
@@ -1,7 +0,0 @@
-package ansi
-
-const Marker = '\x1B'
-
-func IsTerminator(c rune) bool {
- return (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a)
-}
diff --git a/vendor/github.com/muesli/reflow/ansi/buffer.go b/vendor/github.com/muesli/reflow/ansi/buffer.go
deleted file mode 100644
index 471bcaf78..000000000
--- a/vendor/github.com/muesli/reflow/ansi/buffer.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package ansi
-
-import (
- "bytes"
-
- "github.com/mattn/go-runewidth"
-)
-
-// Buffer is a buffer aware of ANSI escape sequences.
-type Buffer struct {
- bytes.Buffer
-}
-
-// PrintableRuneWidth returns the cell width of all printable runes in the
-// buffer.
-func (w Buffer) PrintableRuneWidth() int {
- return PrintableRuneWidth(w.String())
-}
-
-// PrintableRuneWidth returns the cell width of the given string.
-func PrintableRuneWidth(s string) int {
- var n int
- var ansi bool
-
- for _, c := range s {
- if c == Marker {
- // ANSI escape sequence
- ansi = true
- } else if ansi {
- if IsTerminator(c) {
- // ANSI sequence terminated
- ansi = false
- }
- } else {
- n += runewidth.RuneWidth(c)
- }
- }
-
- return n
-}
diff --git a/vendor/github.com/muesli/reflow/ansi/writer.go b/vendor/github.com/muesli/reflow/ansi/writer.go
deleted file mode 100644
index a6aaa1ec6..000000000
--- a/vendor/github.com/muesli/reflow/ansi/writer.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package ansi
-
-import (
- "bytes"
- "io"
- "unicode/utf8"
-)
-
-type Writer struct {
- Forward io.Writer
-
- ansi bool
- ansiseq bytes.Buffer
- lastseq bytes.Buffer
- seqchanged bool
- runeBuf []byte
-}
-
-// Write is used to write content to the ANSI buffer.
-func (w *Writer) Write(b []byte) (int, error) {
- for _, c := range string(b) {
- if c == Marker {
- // ANSI escape sequence
- w.ansi = true
- w.seqchanged = true
- _, _ = w.ansiseq.WriteRune(c)
- } else if w.ansi {
- _, _ = w.ansiseq.WriteRune(c)
- if IsTerminator(c) {
- // ANSI sequence terminated
- w.ansi = false
-
- if bytes.HasSuffix(w.ansiseq.Bytes(), []byte("[0m")) {
- // reset sequence
- w.lastseq.Reset()
- w.seqchanged = false
- } else if c == 'm' {
- // color code
- _, _ = w.lastseq.Write(w.ansiseq.Bytes())
- }
-
- _, _ = w.ansiseq.WriteTo(w.Forward)
- }
- } else {
- _, err := w.writeRune(c)
- if err != nil {
- return 0, err
- }
- }
- }
-
- return len(b), nil
-}
-
-func (w *Writer) writeRune(r rune) (int, error) {
- if w.runeBuf == nil {
- w.runeBuf = make([]byte, utf8.UTFMax)
- }
- n := utf8.EncodeRune(w.runeBuf, r)
- return w.Forward.Write(w.runeBuf[:n])
-}
-
-func (w *Writer) LastSequence() string {
- return w.lastseq.String()
-}
-
-func (w *Writer) ResetAnsi() {
- if !w.seqchanged {
- return
- }
- _, _ = w.Forward.Write([]byte("\x1b[0m"))
-}
-
-func (w *Writer) RestoreAnsi() {
- _, _ = w.Forward.Write(w.lastseq.Bytes())
-}
diff --git a/vendor/github.com/muesli/reflow/truncate/truncate.go b/vendor/github.com/muesli/reflow/truncate/truncate.go
deleted file mode 100644
index 5aab5f896..000000000
--- a/vendor/github.com/muesli/reflow/truncate/truncate.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package truncate
-
-import (
- "bytes"
- "io"
-
- "github.com/mattn/go-runewidth"
-
- "github.com/muesli/reflow/ansi"
-)
-
-type Writer struct {
- width uint
- tail string
-
- ansiWriter *ansi.Writer
- buf bytes.Buffer
- ansi bool
-}
-
-func NewWriter(width uint, tail string) *Writer {
- w := &Writer{
- width: width,
- tail: tail,
- }
- w.ansiWriter = &ansi.Writer{
- Forward: &w.buf,
- }
- return w
-}
-
-func NewWriterPipe(forward io.Writer, width uint, tail string) *Writer {
- return &Writer{
- width: width,
- tail: tail,
- ansiWriter: &ansi.Writer{
- Forward: forward,
- },
- }
-}
-
-// Bytes is shorthand for declaring a new default truncate-writer instance,
-// used to immediately truncate a byte slice.
-func Bytes(b []byte, width uint) []byte {
- return BytesWithTail(b, width, []byte(""))
-}
-
-// Bytes is shorthand for declaring a new default truncate-writer instance,
-// used to immediately truncate a byte slice. A tail is then added to the
-// end of the byte slice.
-func BytesWithTail(b []byte, width uint, tail []byte) []byte {
- f := NewWriter(width, string(tail))
- _, _ = f.Write(b)
-
- return f.Bytes()
-}
-
-// String is shorthand for declaring a new default truncate-writer instance,
-// used to immediately truncate a string.
-func String(s string, width uint) string {
- return StringWithTail(s, width, "")
-}
-
-// StringWithTail is shorthand for declaring a new default truncate-writer instance,
-// used to immediately truncate a string. A tail is then added to the end of the
-// string.
-func StringWithTail(s string, width uint, tail string) string {
- return string(BytesWithTail([]byte(s), width, []byte(tail)))
-}
-
-// Write truncates content at the given printable cell width, leaving any
-// ansi sequences intact.
-func (w *Writer) Write(b []byte) (int, error) {
- tw := ansi.PrintableRuneWidth(w.tail)
- if w.width < uint(tw) {
- return w.buf.WriteString(w.tail)
- }
-
- w.width -= uint(tw)
- var curWidth uint
-
- for _, c := range string(b) {
- if c == ansi.Marker {
- // ANSI escape sequence
- w.ansi = true
- } else if w.ansi {
- if ansi.IsTerminator(c) {
- // ANSI sequence terminated
- w.ansi = false
- }
- } else {
- curWidth += uint(runewidth.RuneWidth(c))
- }
-
- if curWidth > w.width {
- n, err := w.buf.WriteString(w.tail)
- if w.ansiWriter.LastSequence() != "" {
- w.ansiWriter.ResetAnsi()
- }
- return n, err
- }
-
- _, err := w.ansiWriter.Write([]byte(string(c)))
- if err != nil {
- return 0, err
- }
- }
-
- return len(b), nil
-}
-
-// Bytes returns the truncated result as a byte slice.
-func (w *Writer) Bytes() []byte {
- return w.buf.Bytes()
-}
-
-// String returns the truncated result as a string.
-func (w *Writer) String() string {
- return w.buf.String()
-}
diff --git a/vendor/github.com/muesli/reflow/wordwrap/wordwrap.go b/vendor/github.com/muesli/reflow/wordwrap/wordwrap.go
deleted file mode 100644
index 488fb2100..000000000
--- a/vendor/github.com/muesli/reflow/wordwrap/wordwrap.go
+++ /dev/null
@@ -1,167 +0,0 @@
-package wordwrap
-
-import (
- "bytes"
- "strings"
- "unicode"
-
- "github.com/muesli/reflow/ansi"
-)
-
-var (
- defaultBreakpoints = []rune{'-'}
- defaultNewline = []rune{'\n'}
-)
-
-// WordWrap contains settings and state for customisable text reflowing with
-// support for ANSI escape sequences. This means you can style your terminal
-// output without affecting the word wrapping algorithm.
-type WordWrap struct {
- Limit int
- Breakpoints []rune
- Newline []rune
- KeepNewlines bool
-
- buf bytes.Buffer
- space bytes.Buffer
- word ansi.Buffer
-
- lineLen int
- ansi bool
-}
-
-// NewWriter returns a new instance of a word-wrapping writer, initialized with
-// default settings.
-func NewWriter(limit int) *WordWrap {
- return &WordWrap{
- Limit: limit,
- Breakpoints: defaultBreakpoints,
- Newline: defaultNewline,
- KeepNewlines: true,
- }
-}
-
-// Bytes is shorthand for declaring a new default WordWrap instance,
-// used to immediately word-wrap a byte slice.
-func Bytes(b []byte, limit int) []byte {
- f := NewWriter(limit)
- _, _ = f.Write(b)
- _ = f.Close()
-
- return f.Bytes()
-}
-
-// String is shorthand for declaring a new default WordWrap instance,
-// used to immediately word-wrap a string.
-func String(s string, limit int) string {
- return string(Bytes([]byte(s), limit))
-}
-
-func (w *WordWrap) addSpace() {
- w.lineLen += w.space.Len()
- _, _ = w.buf.Write(w.space.Bytes())
- w.space.Reset()
-}
-
-func (w *WordWrap) addWord() {
- if w.word.Len() > 0 {
- w.addSpace()
- w.lineLen += w.word.PrintableRuneWidth()
- _, _ = w.buf.Write(w.word.Bytes())
- w.word.Reset()
- }
-}
-
-func (w *WordWrap) addNewLine() {
- _, _ = w.buf.WriteRune('\n')
- w.lineLen = 0
- w.space.Reset()
-}
-
-func inGroup(a []rune, c rune) bool {
- for _, v := range a {
- if v == c {
- return true
- }
- }
- return false
-}
-
-// Write is used to write more content to the word-wrap buffer.
-func (w *WordWrap) Write(b []byte) (int, error) {
- if w.Limit == 0 {
- return w.buf.Write(b)
- }
-
- s := string(b)
- if !w.KeepNewlines {
- s = strings.Replace(strings.TrimSpace(s), "\n", " ", -1)
- }
-
- for _, c := range s {
- if c == '\x1B' {
- // ANSI escape sequence
- _, _ = w.word.WriteRune(c)
- w.ansi = true
- } else if w.ansi {
- _, _ = w.word.WriteRune(c)
- if (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) {
- // ANSI sequence terminated
- w.ansi = false
- }
- } else if inGroup(w.Newline, c) {
- // end of current line
- // see if we can add the content of the space buffer to the current line
- if w.word.Len() == 0 {
- if w.lineLen+w.space.Len() > w.Limit {
- w.lineLen = 0
- } else {
- // preserve whitespace
- _, _ = w.buf.Write(w.space.Bytes())
- }
- w.space.Reset()
- }
-
- w.addWord()
- w.addNewLine()
- } else if unicode.IsSpace(c) {
- // end of current word
- w.addWord()
- _, _ = w.space.WriteRune(c)
- } else if inGroup(w.Breakpoints, c) {
- // valid breakpoint
- w.addSpace()
- w.addWord()
- _, _ = w.buf.WriteRune(c)
- } else {
- // any other character
- _, _ = w.word.WriteRune(c)
-
- // add a line break if the current word would exceed the line's
- // character limit
- if w.lineLen+w.space.Len()+w.word.PrintableRuneWidth() > w.Limit &&
- w.word.PrintableRuneWidth() < w.Limit {
- w.addNewLine()
- }
- }
- }
-
- return len(b), nil
-}
-
-// Close will finish the word-wrap operation. Always call it before trying to
-// retrieve the final result.
-func (w *WordWrap) Close() error {
- w.addWord()
- return nil
-}
-
-// Bytes returns the word-wrapped result as a byte slice.
-func (w *WordWrap) Bytes() []byte {
- return w.buf.Bytes()
-}
-
-// String returns the word-wrapped result as a string.
-func (w *WordWrap) String() string {
- return w.buf.String()
-}
diff --git a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal/pulumiUtilities.go b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal/pulumiUtilities.go
index b3986eb70..e58ba8cc4 100644
--- a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal/pulumiUtilities.go
+++ b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal/pulumiUtilities.go
@@ -165,7 +165,7 @@ func callPlainInner(
func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption {
defaults := []pulumi.ResourceOption{}
- version := semver.MustParse("1.73.1")
+ version := semver.MustParse("1.74.1")
if !version.Equals(semver.Version{}) {
defaults = append(defaults, pulumi.Version(version.String()))
}
@@ -176,7 +176,7 @@ func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOptio
func PkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption {
defaults := []pulumi.InvokeOption{}
- version := semver.MustParse("1.73.1")
+ version := semver.MustParse("1.74.1")
if !version.Equals(semver.Version{}) {
defaults = append(defaults, pulumi.Version(version.String()))
}
diff --git a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/pulumi-plugin.json
index be9459f68..c02a03fd1 100644
--- a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "aws-native",
- "version": "1.73.1"
+ "version": "1.74.1"
}
diff --git a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/getServiceSetting.go b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/getServiceSetting.go
new file mode 100644
index 000000000..03342f457
--- /dev/null
+++ b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/getServiceSetting.go
@@ -0,0 +1,102 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package ssm
+
+import (
+ "context"
+ "reflect"
+
+ "github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal"
+ "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// Resource Type definition for AWS::SSM::ServiceSetting. ServiceSetting is an account-level setting for an AWS service that defines how a user interacts with or uses a service or feature.
+func LookupServiceSetting(ctx *pulumi.Context, args *LookupServiceSettingArgs, opts ...pulumi.InvokeOption) (*LookupServiceSettingResult, error) {
+ opts = internal.PkgInvokeDefaultOpts(opts)
+ var rv LookupServiceSettingResult
+ err := ctx.Invoke("aws-native:ssm:getServiceSetting", args, &rv, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return &rv, nil
+}
+
+type LookupServiceSettingArgs struct {
+ // The ARN of the service setting.
+ Arn string `pulumi:"arn"`
+}
+
+type LookupServiceSettingResult struct {
+ // The ARN of the service setting.
+ Arn *string `pulumi:"arn"`
+ // The last time the service setting was modified.
+ LastModifiedDate *string `pulumi:"lastModifiedDate"`
+ // The ARN of the last modified user.
+ LastModifiedUser *string `pulumi:"lastModifiedUser"`
+ // The value of the service setting.
+ SettingValue *string `pulumi:"settingValue"`
+ // The status of the service setting. The value can be Default, Customized or PendingUpdate.
+ Status *string `pulumi:"status"`
+}
+
+func LookupServiceSettingOutput(ctx *pulumi.Context, args LookupServiceSettingOutputArgs, opts ...pulumi.InvokeOption) LookupServiceSettingResultOutput {
+ return pulumi.ToOutputWithContext(ctx.Context(), args).
+ ApplyT(func(v interface{}) (LookupServiceSettingResultOutput, error) {
+ args := v.(LookupServiceSettingArgs)
+ options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)}
+ return ctx.InvokeOutput("aws-native:ssm:getServiceSetting", args, LookupServiceSettingResultOutput{}, options).(LookupServiceSettingResultOutput), nil
+ }).(LookupServiceSettingResultOutput)
+}
+
+type LookupServiceSettingOutputArgs struct {
+ // The ARN of the service setting.
+ Arn pulumi.StringInput `pulumi:"arn"`
+}
+
+func (LookupServiceSettingOutputArgs) ElementType() reflect.Type {
+ return reflect.TypeOf((*LookupServiceSettingArgs)(nil)).Elem()
+}
+
+type LookupServiceSettingResultOutput struct{ *pulumi.OutputState }
+
+func (LookupServiceSettingResultOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*LookupServiceSettingResult)(nil)).Elem()
+}
+
+func (o LookupServiceSettingResultOutput) ToLookupServiceSettingResultOutput() LookupServiceSettingResultOutput {
+ return o
+}
+
+func (o LookupServiceSettingResultOutput) ToLookupServiceSettingResultOutputWithContext(ctx context.Context) LookupServiceSettingResultOutput {
+ return o
+}
+
+// The ARN of the service setting.
+func (o LookupServiceSettingResultOutput) Arn() pulumi.StringPtrOutput {
+ return o.ApplyT(func(v LookupServiceSettingResult) *string { return v.Arn }).(pulumi.StringPtrOutput)
+}
+
+// The last time the service setting was modified.
+func (o LookupServiceSettingResultOutput) LastModifiedDate() pulumi.StringPtrOutput {
+ return o.ApplyT(func(v LookupServiceSettingResult) *string { return v.LastModifiedDate }).(pulumi.StringPtrOutput)
+}
+
+// The ARN of the last modified user.
+func (o LookupServiceSettingResultOutput) LastModifiedUser() pulumi.StringPtrOutput {
+ return o.ApplyT(func(v LookupServiceSettingResult) *string { return v.LastModifiedUser }).(pulumi.StringPtrOutput)
+}
+
+// The value of the service setting.
+func (o LookupServiceSettingResultOutput) SettingValue() pulumi.StringPtrOutput {
+ return o.ApplyT(func(v LookupServiceSettingResult) *string { return v.SettingValue }).(pulumi.StringPtrOutput)
+}
+
+// The status of the service setting. The value can be Default, Customized or PendingUpdate.
+func (o LookupServiceSettingResultOutput) Status() pulumi.StringPtrOutput {
+ return o.ApplyT(func(v LookupServiceSettingResult) *string { return v.Status }).(pulumi.StringPtrOutput)
+}
+
+func init() {
+ pulumi.RegisterOutputType(LookupServiceSettingResultOutput{})
+}
diff --git a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/init.go b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/init.go
index c91ca2ab3..021f7c4bc 100644
--- a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/init.go
+++ b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/init.go
@@ -41,6 +41,8 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi
r = &ResourceDataSync{}
case "aws-native:ssm:ResourcePolicy":
r = &ResourcePolicy{}
+ case "aws-native:ssm:ServiceSetting":
+ r = &ServiceSetting{}
default:
return nil, fmt.Errorf("unknown resource type: %s", typ)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/serviceSetting.go b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/serviceSetting.go
new file mode 100644
index 000000000..e80f34920
--- /dev/null
+++ b/vendor/github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm/serviceSetting.go
@@ -0,0 +1,167 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package ssm
+
+import (
+ "context"
+ "reflect"
+
+ "errors"
+ "github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal"
+ "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// Resource Type definition for AWS::SSM::ServiceSetting. ServiceSetting is an account-level setting for an AWS service that defines how a user interacts with or uses a service or feature.
+type ServiceSetting struct {
+ pulumi.CustomResourceState
+
+ // The ARN of the service setting.
+ Arn pulumi.StringOutput `pulumi:"arn"`
+ // The last time the service setting was modified.
+ LastModifiedDate pulumi.StringOutput `pulumi:"lastModifiedDate"`
+ // The ARN of the last modified user.
+ LastModifiedUser pulumi.StringOutput `pulumi:"lastModifiedUser"`
+ // The ID of the service setting, such as /ssm/parameter-store/high-throughput-enabled.
+ SettingId pulumi.StringOutput `pulumi:"settingId"`
+ // The value of the service setting.
+ SettingValue pulumi.StringOutput `pulumi:"settingValue"`
+ // The status of the service setting. The value can be Default, Customized or PendingUpdate.
+ Status pulumi.StringOutput `pulumi:"status"`
+}
+
+// NewServiceSetting registers a new resource with the given unique name, arguments, and options.
+func NewServiceSetting(ctx *pulumi.Context,
+ name string, args *ServiceSettingArgs, opts ...pulumi.ResourceOption) (*ServiceSetting, error) {
+ if args == nil {
+ return nil, errors.New("missing one or more required arguments")
+ }
+
+ if args.SettingId == nil {
+ return nil, errors.New("invalid value for required argument 'SettingId'")
+ }
+ if args.SettingValue == nil {
+ return nil, errors.New("invalid value for required argument 'SettingValue'")
+ }
+ replaceOnChanges := pulumi.ReplaceOnChanges([]string{
+ "settingId",
+ })
+ opts = append(opts, replaceOnChanges)
+ opts = internal.PkgResourceDefaultOpts(opts)
+ var resource ServiceSetting
+ err := ctx.RegisterResource("aws-native:ssm:ServiceSetting", name, args, &resource, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return &resource, nil
+}
+
+// GetServiceSetting gets an existing ServiceSetting resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetServiceSetting(ctx *pulumi.Context,
+ name string, id pulumi.IDInput, state *ServiceSettingState, opts ...pulumi.ResourceOption) (*ServiceSetting, error) {
+ var resource ServiceSetting
+ err := ctx.ReadResource("aws-native:ssm:ServiceSetting", name, id, state, &resource, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return &resource, nil
+}
+
+// Input properties used for looking up and filtering ServiceSetting resources.
+type serviceSettingState struct {
+}
+
+type ServiceSettingState struct {
+}
+
+func (ServiceSettingState) ElementType() reflect.Type {
+ return reflect.TypeOf((*serviceSettingState)(nil)).Elem()
+}
+
+type serviceSettingArgs struct {
+ // The ID of the service setting, such as /ssm/parameter-store/high-throughput-enabled.
+ SettingId string `pulumi:"settingId"`
+ // The value of the service setting.
+ SettingValue string `pulumi:"settingValue"`
+}
+
+// The set of arguments for constructing a ServiceSetting resource.
+type ServiceSettingArgs struct {
+ // The ID of the service setting, such as /ssm/parameter-store/high-throughput-enabled.
+ SettingId pulumi.StringInput
+ // The value of the service setting.
+ SettingValue pulumi.StringInput
+}
+
+func (ServiceSettingArgs) ElementType() reflect.Type {
+ return reflect.TypeOf((*serviceSettingArgs)(nil)).Elem()
+}
+
+type ServiceSettingInput interface {
+ pulumi.Input
+
+ ToServiceSettingOutput() ServiceSettingOutput
+ ToServiceSettingOutputWithContext(ctx context.Context) ServiceSettingOutput
+}
+
+func (*ServiceSetting) ElementType() reflect.Type {
+ return reflect.TypeOf((**ServiceSetting)(nil)).Elem()
+}
+
+func (i *ServiceSetting) ToServiceSettingOutput() ServiceSettingOutput {
+ return i.ToServiceSettingOutputWithContext(context.Background())
+}
+
+func (i *ServiceSetting) ToServiceSettingOutputWithContext(ctx context.Context) ServiceSettingOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(ServiceSettingOutput)
+}
+
+type ServiceSettingOutput struct{ *pulumi.OutputState }
+
+func (ServiceSettingOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((**ServiceSetting)(nil)).Elem()
+}
+
+func (o ServiceSettingOutput) ToServiceSettingOutput() ServiceSettingOutput {
+ return o
+}
+
+func (o ServiceSettingOutput) ToServiceSettingOutputWithContext(ctx context.Context) ServiceSettingOutput {
+ return o
+}
+
+// The ARN of the service setting.
+func (o ServiceSettingOutput) Arn() pulumi.StringOutput {
+ return o.ApplyT(func(v *ServiceSetting) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput)
+}
+
+// The last time the service setting was modified.
+func (o ServiceSettingOutput) LastModifiedDate() pulumi.StringOutput {
+ return o.ApplyT(func(v *ServiceSetting) pulumi.StringOutput { return v.LastModifiedDate }).(pulumi.StringOutput)
+}
+
+// The ARN of the last modified user.
+func (o ServiceSettingOutput) LastModifiedUser() pulumi.StringOutput {
+ return o.ApplyT(func(v *ServiceSetting) pulumi.StringOutput { return v.LastModifiedUser }).(pulumi.StringOutput)
+}
+
+// The ID of the service setting, such as /ssm/parameter-store/high-throughput-enabled.
+func (o ServiceSettingOutput) SettingId() pulumi.StringOutput {
+ return o.ApplyT(func(v *ServiceSetting) pulumi.StringOutput { return v.SettingId }).(pulumi.StringOutput)
+}
+
+// The value of the service setting.
+func (o ServiceSettingOutput) SettingValue() pulumi.StringOutput {
+ return o.ApplyT(func(v *ServiceSetting) pulumi.StringOutput { return v.SettingValue }).(pulumi.StringOutput)
+}
+
+// The status of the service setting. The value can be Default, Customized or PendingUpdate.
+func (o ServiceSettingOutput) Status() pulumi.StringOutput {
+ return o.ApplyT(func(v *ServiceSetting) pulumi.StringOutput { return v.Status }).(pulumi.StringOutput)
+}
+
+func init() {
+ pulumi.RegisterInputType(reflect.TypeOf((*ServiceSettingInput)(nil)).Elem(), &ServiceSetting{})
+ pulumi.RegisterOutputType(ServiceSettingOutput{})
+}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling/pulumiTypes.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling/pulumiTypes.go
index 76fbe0c80..15602f966 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling/pulumiTypes.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling/pulumiTypes.go
@@ -14,7 +14,7 @@ import (
var _ = internal.GetEnvOrDefault
type GroupAvailabilityZoneDistribution struct {
- // The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only` and `balanced-best-effort`. Default is `balanced-best-effort`.
+ // The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only`, `balanced-best-effort`, and `reservations-then-balanced`. Default is `balanced-best-effort`. When `reservations-then-balanced` is set, you must also specify Capacity Reservations to prioritize through `capacityReservationSpecification` (or via a launch template) using a Capacity Reservation ID or Capacity Reservation resource group ARN.
CapacityDistributionStrategy *string `pulumi:"capacityDistributionStrategy"`
}
@@ -30,7 +30,7 @@ type GroupAvailabilityZoneDistributionInput interface {
}
type GroupAvailabilityZoneDistributionArgs struct {
- // The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only` and `balanced-best-effort`. Default is `balanced-best-effort`.
+ // The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only`, `balanced-best-effort`, and `reservations-then-balanced`. Default is `balanced-best-effort`. When `reservations-then-balanced` is set, you must also specify Capacity Reservations to prioritize through `capacityReservationSpecification` (or via a launch template) using a Capacity Reservation ID or Capacity Reservation resource group ARN.
CapacityDistributionStrategy pulumi.StringPtrInput `pulumi:"capacityDistributionStrategy"`
}
@@ -111,7 +111,7 @@ func (o GroupAvailabilityZoneDistributionOutput) ToGroupAvailabilityZoneDistribu
}).(GroupAvailabilityZoneDistributionPtrOutput)
}
-// The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only` and `balanced-best-effort`. Default is `balanced-best-effort`.
+// The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only`, `balanced-best-effort`, and `reservations-then-balanced`. Default is `balanced-best-effort`. When `reservations-then-balanced` is set, you must also specify Capacity Reservations to prioritize through `capacityReservationSpecification` (or via a launch template) using a Capacity Reservation ID or Capacity Reservation resource group ARN.
func (o GroupAvailabilityZoneDistributionOutput) CapacityDistributionStrategy() pulumi.StringPtrOutput {
return o.ApplyT(func(v GroupAvailabilityZoneDistribution) *string { return v.CapacityDistributionStrategy }).(pulumi.StringPtrOutput)
}
@@ -140,7 +140,7 @@ func (o GroupAvailabilityZoneDistributionPtrOutput) Elem() GroupAvailabilityZone
}).(GroupAvailabilityZoneDistributionOutput)
}
-// The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only` and `balanced-best-effort`. Default is `balanced-best-effort`.
+// The strategy to use for distributing capacity across the Availability Zones. Valid values are `balanced-only`, `balanced-best-effort`, and `reservations-then-balanced`. Default is `balanced-best-effort`. When `reservations-then-balanced` is set, you must also specify Capacity Reservations to prioritize through `capacityReservationSpecification` (or via a launch template) using a Capacity Reservation ID or Capacity Reservation resource group ARN.
func (o GroupAvailabilityZoneDistributionPtrOutput) CapacityDistributionStrategy() pulumi.StringPtrOutput {
return o.ApplyT(func(v *GroupAvailabilityZoneDistribution) *string {
if v == nil {
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getContributorManagedInsightRules.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getContributorManagedInsightRules.go
index 9b13cf60e..aa493a473 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getContributorManagedInsightRules.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getContributorManagedInsightRules.go
@@ -60,8 +60,6 @@ type GetContributorManagedInsightRulesArgs struct {
// A collection of values returned by getContributorManagedInsightRules.
type GetContributorManagedInsightRulesResult struct {
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// Managed rules that are available for the specified Amazon Web Services resource. See `managedRules reference` below for details.
ManagedRules []GetContributorManagedInsightRulesManagedRule `pulumi:"managedRules"`
Region string `pulumi:"region"`
@@ -105,11 +103,6 @@ func (o GetContributorManagedInsightRulesResultOutput) ToGetContributorManagedIn
return o
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetContributorManagedInsightRulesResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetContributorManagedInsightRulesResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// Managed rules that are available for the specified Amazon Web Services resource. See `managedRules reference` below for details.
func (o GetContributorManagedInsightRulesResultOutput) ManagedRules() GetContributorManagedInsightRulesManagedRuleArrayOutput {
return o.ApplyT(func(v GetContributorManagedInsightRulesResult) []GetContributorManagedInsightRulesManagedRule {
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getEventBuses.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getEventBuses.go
index c5c409f82..9f0eb3154 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getEventBuses.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/getEventBuses.go
@@ -62,10 +62,8 @@ type GetEventBusesArgs struct {
type GetEventBusesResult struct {
// This list of event buses.
EventBuses []GetEventBusesEventBus `pulumi:"eventBuses"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- NamePrefix *string `pulumi:"namePrefix"`
- Region string `pulumi:"region"`
+ NamePrefix *string `pulumi:"namePrefix"`
+ Region string `pulumi:"region"`
}
func GetEventBusesOutput(ctx *pulumi.Context, args GetEventBusesOutputArgs, opts ...pulumi.InvokeOption) GetEventBusesResultOutput {
@@ -109,11 +107,6 @@ func (o GetEventBusesResultOutput) EventBuses() GetEventBusesEventBusArrayOutput
return o.ApplyT(func(v GetEventBusesResult) []GetEventBusesEventBus { return v.EventBuses }).(GetEventBusesEventBusArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetEventBusesResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetEventBusesResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetEventBusesResultOutput) NamePrefix() pulumi.StringPtrOutput {
return o.ApplyT(func(v GetEventBusesResult) *string { return v.NamePrefix }).(pulumi.StringPtrOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/init.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/init.go
index 9e8daeff6..b911e605d 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/init.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/init.go
@@ -79,6 +79,8 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi
r = &LogResourcePolicy{}
case "aws:cloudwatch/logS3TableIntegrationSource:LogS3TableIntegrationSource":
r = &LogS3TableIntegrationSource{}
+ case "aws:cloudwatch/logStorageTierPolicy:LogStorageTierPolicy":
+ r = &LogStorageTierPolicy{}
case "aws:cloudwatch/logStream:LogStream":
r = &LogStream{}
case "aws:cloudwatch/logSubscriptionFilter:LogSubscriptionFilter":
@@ -251,6 +253,11 @@ func init() {
"cloudwatch/logS3TableIntegrationSource",
&module{version},
)
+ pulumi.RegisterResourceModule(
+ "aws",
+ "cloudwatch/logStorageTierPolicy",
+ &module{version},
+ )
pulumi.RegisterResourceModule(
"aws",
"cloudwatch/logStream",
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDelivery.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDelivery.go
index 4ee5ac7ec..9e498aaae 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDelivery.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDelivery.go
@@ -48,6 +48,61 @@ import (
//
// ```
//
+// ### CloudFront Standard Logging (v2)
+//
+// CloudFront delivers access logs through CloudWatch Logs, so a distribution's standard logging (v2) configuration is expressed as a delivery source, a delivery destination, and a delivery. The `recordFields` list selects the access log fields, including `viewer-request-log-data` and `viewer-response-log-data`, which carry the custom data that a viewer request or viewer response CloudFront Function logs with `cf.logCustomData()`.
+//
+// ```go
+// package main
+//
+// import (
+//
+// "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
+// "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+//
+// )
+//
+// func main() {
+// pulumi.Run(func(ctx *pulumi.Context) error {
+// example, err := cloudwatch.NewLogDeliverySource(ctx, "example", &cloudwatch.LogDeliverySourceArgs{
+// Name: pulumi.String("cloudfront-access-logs"),
+// LogType: pulumi.String("ACCESS_LOGS"),
+// ResourceArn: pulumi.Any(exampleAwsCloudfrontDistribution.Arn),
+// })
+// if err != nil {
+// return err
+// }
+// exampleLogDeliveryDestination, err := cloudwatch.NewLogDeliveryDestination(ctx, "example", &cloudwatch.LogDeliveryDestinationArgs{
+// Name: pulumi.String("cloudfront-access-logs"),
+// OutputFormat: pulumi.String("json"),
+// DeliveryDestinationConfiguration: &cloudwatch.LogDeliveryDestinationDeliveryDestinationConfigurationArgs{
+// DestinationResourceArn: pulumi.Any(exampleAwsCloudwatchLogGroup.Arn),
+// },
+// })
+// if err != nil {
+// return err
+// }
+// _, err = cloudwatch.NewLogDelivery(ctx, "example", &cloudwatch.LogDeliveryArgs{
+// DeliverySourceName: example.Name,
+// DeliveryDestinationArn: exampleLogDeliveryDestination.Arn,
+// RecordFields: pulumi.StringArray{
+// pulumi.String("date"),
+// pulumi.String("time"),
+// pulumi.String("c-ip"),
+// pulumi.String("sc-status"),
+// pulumi.String("viewer-request-log-data"),
+// pulumi.String("viewer-response-log-data"),
+// },
+// })
+// if err != nil {
+// return err
+// }
+// return nil
+// })
+// }
+//
+// ```
+//
// ## Import
//
// ### Identity Schema
@@ -77,7 +132,7 @@ type LogDelivery struct {
DeliverySourceName pulumi.StringOutput `pulumi:"deliverySourceName"`
// The field delimiter to use between record fields when the final output format of a delivery is in `plain`, `w3c`, or `raw` format.
FieldDelimiter pulumi.StringOutput `pulumi:"fieldDelimiter"`
- // The list of record fields to be delivered to the destination, in order.
+ // The list of record fields to be delivered to the destination, in order. The valid field names vary by the `logType` of the delivery source. For a CloudFront `ACCESS_LOGS` source, see [Configure standard logging (v2)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/standard-logging.html#standard-logging-real-time-log-selection) for the supported values.
RecordFields pulumi.StringArrayOutput `pulumi:"recordFields"`
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region pulumi.StringOutput `pulumi:"region"`
@@ -133,7 +188,7 @@ type logDeliveryState struct {
DeliverySourceName *string `pulumi:"deliverySourceName"`
// The field delimiter to use between record fields when the final output format of a delivery is in `plain`, `w3c`, or `raw` format.
FieldDelimiter *string `pulumi:"fieldDelimiter"`
- // The list of record fields to be delivered to the destination, in order.
+ // The list of record fields to be delivered to the destination, in order. The valid field names vary by the `logType` of the delivery source. For a CloudFront `ACCESS_LOGS` source, see [Configure standard logging (v2)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/standard-logging.html#standard-logging-real-time-log-selection) for the supported values.
RecordFields []string `pulumi:"recordFields"`
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region *string `pulumi:"region"`
@@ -154,7 +209,7 @@ type LogDeliveryState struct {
DeliverySourceName pulumi.StringPtrInput
// The field delimiter to use between record fields when the final output format of a delivery is in `plain`, `w3c`, or `raw` format.
FieldDelimiter pulumi.StringPtrInput
- // The list of record fields to be delivered to the destination, in order.
+ // The list of record fields to be delivered to the destination, in order. The valid field names vary by the `logType` of the delivery source. For a CloudFront `ACCESS_LOGS` source, see [Configure standard logging (v2)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/standard-logging.html#standard-logging-real-time-log-selection) for the supported values.
RecordFields pulumi.StringArrayInput
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region pulumi.StringPtrInput
@@ -177,7 +232,7 @@ type logDeliveryArgs struct {
DeliverySourceName string `pulumi:"deliverySourceName"`
// The field delimiter to use between record fields when the final output format of a delivery is in `plain`, `w3c`, or `raw` format.
FieldDelimiter *string `pulumi:"fieldDelimiter"`
- // The list of record fields to be delivered to the destination, in order.
+ // The list of record fields to be delivered to the destination, in order. The valid field names vary by the `logType` of the delivery source. For a CloudFront `ACCESS_LOGS` source, see [Configure standard logging (v2)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/standard-logging.html#standard-logging-real-time-log-selection) for the supported values.
RecordFields []string `pulumi:"recordFields"`
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region *string `pulumi:"region"`
@@ -195,7 +250,7 @@ type LogDeliveryArgs struct {
DeliverySourceName pulumi.StringInput
// The field delimiter to use between record fields when the final output format of a delivery is in `plain`, `w3c`, or `raw` format.
FieldDelimiter pulumi.StringPtrInput
- // The list of record fields to be delivered to the destination, in order.
+ // The list of record fields to be delivered to the destination, in order. The valid field names vary by the `logType` of the delivery source. For a CloudFront `ACCESS_LOGS` source, see [Configure standard logging (v2)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/standard-logging.html#standard-logging-real-time-log-selection) for the supported values.
RecordFields pulumi.StringArrayInput
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region pulumi.StringPtrInput
@@ -312,7 +367,7 @@ func (o LogDeliveryOutput) FieldDelimiter() pulumi.StringOutput {
return o.ApplyT(func(v *LogDelivery) pulumi.StringOutput { return v.FieldDelimiter }).(pulumi.StringOutput)
}
-// The list of record fields to be delivered to the destination, in order.
+// The list of record fields to be delivered to the destination, in order. The valid field names vary by the `logType` of the delivery source. For a CloudFront `ACCESS_LOGS` source, see [Configure standard logging (v2)](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/standard-logging.html#standard-logging-real-time-log-selection) for the supported values.
func (o LogDeliveryOutput) RecordFields() pulumi.StringArrayOutput {
return o.ApplyT(func(v *LogDelivery) pulumi.StringArrayOutput { return v.RecordFields }).(pulumi.StringArrayOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDeliverySource.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDeliverySource.go
index c7c39c31a..38f9720b2 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDeliverySource.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logDeliverySource.go
@@ -67,7 +67,7 @@ type LogDeliverySource struct {
// The Amazon Resource Name (ARN) of the delivery source.
Arn pulumi.StringOutput `pulumi:"arn"`
- // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
+ // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CloudFront, the valid value is `ACCESS_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
LogType pulumi.StringOutput `pulumi:"logType"`
// The name for this delivery source.
Name pulumi.StringOutput `pulumi:"name"`
@@ -121,7 +121,7 @@ func GetLogDeliverySource(ctx *pulumi.Context,
type logDeliverySourceState struct {
// The Amazon Resource Name (ARN) of the delivery source.
Arn *string `pulumi:"arn"`
- // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
+ // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CloudFront, the valid value is `ACCESS_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
LogType *string `pulumi:"logType"`
// The name for this delivery source.
Name *string `pulumi:"name"`
@@ -140,7 +140,7 @@ type logDeliverySourceState struct {
type LogDeliverySourceState struct {
// The Amazon Resource Name (ARN) of the delivery source.
Arn pulumi.StringPtrInput
- // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
+ // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CloudFront, the valid value is `ACCESS_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
LogType pulumi.StringPtrInput
// The name for this delivery source.
Name pulumi.StringPtrInput
@@ -161,7 +161,7 @@ func (LogDeliverySourceState) ElementType() reflect.Type {
}
type logDeliverySourceArgs struct {
- // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
+ // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CloudFront, the valid value is `ACCESS_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
LogType string `pulumi:"logType"`
// The name for this delivery source.
Name *string `pulumi:"name"`
@@ -175,7 +175,7 @@ type logDeliverySourceArgs struct {
// The set of arguments for constructing a LogDeliverySource resource.
type LogDeliverySourceArgs struct {
- // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
+ // The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CloudFront, the valid value is `ACCESS_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
LogType pulumi.StringInput
// The name for this delivery source.
Name pulumi.StringPtrInput
@@ -279,7 +279,7 @@ func (o LogDeliverySourceOutput) Arn() pulumi.StringOutput {
return o.ApplyT(func(v *LogDeliverySource) pulumi.StringOutput { return v.Arn }).(pulumi.StringOutput)
}
-// The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
+// The type of log that the source is sending. For Amazon Bedrock, the valid value is `APPLICATION_LOGS`. For Amazon Bedrock AgentCore, the valid values are `APPLICATION_LOGS`, `TRACES`, and `USAGE_LOGS`. For Amazon CloudFront, the valid value is `ACCESS_LOGS`. For Amazon CodeWhisperer, the valid value is `EVENT_LOGS`. For IAM Identity Center, the valid value is `ERROR_LOGS`. For Amazon WorkMail, the valid values are `ACCESS_CONTROL_LOGS`, `AUTHENTICATION_LOGS`, `WORKMAIL_AVAILABILITY_PROVIDER_LOGS`, and `WORKMAIL_MAILBOX_ACCESS_LOGS`. See [Enable logging from AWS services](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AWS-logs-and-resource-policy.html) for the log types supported by each service.
func (o LogDeliverySourceOutput) LogType() pulumi.StringOutput {
return o.ApplyT(func(v *LogDeliverySource) pulumi.StringOutput { return v.LogType }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logStorageTierPolicy.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logStorageTierPolicy.go
new file mode 100644
index 000000000..9d2802fba
--- /dev/null
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch/logStorageTierPolicy.go
@@ -0,0 +1,282 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package cloudwatch
+
+import (
+ "context"
+ "reflect"
+
+ "errors"
+ "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/internal"
+ "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// Manages a CloudWatch Logs account-level storage tier policy. When set to `INTELLIGENT_TIERING`, CloudWatch Logs automatically moves log data to the most cost-effective storage tier based on access frequency.
+//
+// > Deletion of this resource will reset the storage tier policy to `STANDARD` (the default state).
+//
+// ## Example Usage
+//
+// ### Basic Usage
+//
+// ```go
+// package main
+//
+// import (
+//
+// "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
+// "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+//
+// )
+//
+// func main() {
+// pulumi.Run(func(ctx *pulumi.Context) error {
+// _, err := cloudwatch.NewLogStorageTierPolicy(ctx, "example", &cloudwatch.LogStorageTierPolicyArgs{
+// StorageTier: pulumi.String("INTELLIGENT_TIERING"),
+// })
+// if err != nil {
+// return err
+// }
+// return nil
+// })
+// }
+//
+// ```
+//
+// ## Import
+//
+// ### Identity Schema
+//
+// #### Required
+//
+// * `region` (String) Region where this resource is managed.
+//
+// #### Optional
+//
+// * `accountId` (String) AWS Account where this resource is managed.
+//
+// Using `pulumi import`, import storage tier policies using `region`. For example:
+//
+// ```sh
+// $ pulumi import aws:cloudwatch/logStorageTierPolicy:LogStorageTierPolicy example us-west-2
+// ```
+type LogStorageTierPolicy struct {
+ pulumi.CustomResourceState
+
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region pulumi.StringOutput `pulumi:"region"`
+ // Storage tier to set for the account. Valid values are `STANDARD` or `INTELLIGENT_TIERING`.
+ StorageTier pulumi.StringOutput `pulumi:"storageTier"`
+}
+
+// NewLogStorageTierPolicy registers a new resource with the given unique name, arguments, and options.
+func NewLogStorageTierPolicy(ctx *pulumi.Context,
+ name string, args *LogStorageTierPolicyArgs, opts ...pulumi.ResourceOption) (*LogStorageTierPolicy, error) {
+ if args == nil {
+ return nil, errors.New("missing one or more required arguments")
+ }
+
+ if args.StorageTier == nil {
+ return nil, errors.New("invalid value for required argument 'StorageTier'")
+ }
+ opts = internal.PkgResourceDefaultOpts(opts)
+ var resource LogStorageTierPolicy
+ err := ctx.RegisterResource("aws:cloudwatch/logStorageTierPolicy:LogStorageTierPolicy", name, args, &resource, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return &resource, nil
+}
+
+// GetLogStorageTierPolicy gets an existing LogStorageTierPolicy resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetLogStorageTierPolicy(ctx *pulumi.Context,
+ name string, id pulumi.IDInput, state *LogStorageTierPolicyState, opts ...pulumi.ResourceOption) (*LogStorageTierPolicy, error) {
+ var resource LogStorageTierPolicy
+ err := ctx.ReadResource("aws:cloudwatch/logStorageTierPolicy:LogStorageTierPolicy", name, id, state, &resource, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return &resource, nil
+}
+
+// Input properties used for looking up and filtering LogStorageTierPolicy resources.
+type logStorageTierPolicyState struct {
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region *string `pulumi:"region"`
+ // Storage tier to set for the account. Valid values are `STANDARD` or `INTELLIGENT_TIERING`.
+ StorageTier *string `pulumi:"storageTier"`
+}
+
+type LogStorageTierPolicyState struct {
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region pulumi.StringPtrInput
+ // Storage tier to set for the account. Valid values are `STANDARD` or `INTELLIGENT_TIERING`.
+ StorageTier pulumi.StringPtrInput
+}
+
+func (LogStorageTierPolicyState) ElementType() reflect.Type {
+ return reflect.TypeOf((*logStorageTierPolicyState)(nil)).Elem()
+}
+
+type logStorageTierPolicyArgs struct {
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region *string `pulumi:"region"`
+ // Storage tier to set for the account. Valid values are `STANDARD` or `INTELLIGENT_TIERING`.
+ StorageTier string `pulumi:"storageTier"`
+}
+
+// The set of arguments for constructing a LogStorageTierPolicy resource.
+type LogStorageTierPolicyArgs struct {
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region pulumi.StringPtrInput
+ // Storage tier to set for the account. Valid values are `STANDARD` or `INTELLIGENT_TIERING`.
+ StorageTier pulumi.StringInput
+}
+
+func (LogStorageTierPolicyArgs) ElementType() reflect.Type {
+ return reflect.TypeOf((*logStorageTierPolicyArgs)(nil)).Elem()
+}
+
+type LogStorageTierPolicyInput interface {
+ pulumi.Input
+
+ ToLogStorageTierPolicyOutput() LogStorageTierPolicyOutput
+ ToLogStorageTierPolicyOutputWithContext(ctx context.Context) LogStorageTierPolicyOutput
+}
+
+func (*LogStorageTierPolicy) ElementType() reflect.Type {
+ return reflect.TypeOf((**LogStorageTierPolicy)(nil)).Elem()
+}
+
+func (i *LogStorageTierPolicy) ToLogStorageTierPolicyOutput() LogStorageTierPolicyOutput {
+ return i.ToLogStorageTierPolicyOutputWithContext(context.Background())
+}
+
+func (i *LogStorageTierPolicy) ToLogStorageTierPolicyOutputWithContext(ctx context.Context) LogStorageTierPolicyOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(LogStorageTierPolicyOutput)
+}
+
+// LogStorageTierPolicyArrayInput is an input type that accepts LogStorageTierPolicyArray and LogStorageTierPolicyArrayOutput values.
+// You can construct a concrete instance of `LogStorageTierPolicyArrayInput` via:
+//
+// LogStorageTierPolicyArray{ LogStorageTierPolicyArgs{...} }
+type LogStorageTierPolicyArrayInput interface {
+ pulumi.Input
+
+ ToLogStorageTierPolicyArrayOutput() LogStorageTierPolicyArrayOutput
+ ToLogStorageTierPolicyArrayOutputWithContext(context.Context) LogStorageTierPolicyArrayOutput
+}
+
+type LogStorageTierPolicyArray []LogStorageTierPolicyInput
+
+func (LogStorageTierPolicyArray) ElementType() reflect.Type {
+ return reflect.TypeOf((*[]*LogStorageTierPolicy)(nil)).Elem()
+}
+
+func (i LogStorageTierPolicyArray) ToLogStorageTierPolicyArrayOutput() LogStorageTierPolicyArrayOutput {
+ return i.ToLogStorageTierPolicyArrayOutputWithContext(context.Background())
+}
+
+func (i LogStorageTierPolicyArray) ToLogStorageTierPolicyArrayOutputWithContext(ctx context.Context) LogStorageTierPolicyArrayOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(LogStorageTierPolicyArrayOutput)
+}
+
+// LogStorageTierPolicyMapInput is an input type that accepts LogStorageTierPolicyMap and LogStorageTierPolicyMapOutput values.
+// You can construct a concrete instance of `LogStorageTierPolicyMapInput` via:
+//
+// LogStorageTierPolicyMap{ "key": LogStorageTierPolicyArgs{...} }
+type LogStorageTierPolicyMapInput interface {
+ pulumi.Input
+
+ ToLogStorageTierPolicyMapOutput() LogStorageTierPolicyMapOutput
+ ToLogStorageTierPolicyMapOutputWithContext(context.Context) LogStorageTierPolicyMapOutput
+}
+
+type LogStorageTierPolicyMap map[string]LogStorageTierPolicyInput
+
+func (LogStorageTierPolicyMap) ElementType() reflect.Type {
+ return reflect.TypeOf((*map[string]*LogStorageTierPolicy)(nil)).Elem()
+}
+
+func (i LogStorageTierPolicyMap) ToLogStorageTierPolicyMapOutput() LogStorageTierPolicyMapOutput {
+ return i.ToLogStorageTierPolicyMapOutputWithContext(context.Background())
+}
+
+func (i LogStorageTierPolicyMap) ToLogStorageTierPolicyMapOutputWithContext(ctx context.Context) LogStorageTierPolicyMapOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(LogStorageTierPolicyMapOutput)
+}
+
+type LogStorageTierPolicyOutput struct{ *pulumi.OutputState }
+
+func (LogStorageTierPolicyOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((**LogStorageTierPolicy)(nil)).Elem()
+}
+
+func (o LogStorageTierPolicyOutput) ToLogStorageTierPolicyOutput() LogStorageTierPolicyOutput {
+ return o
+}
+
+func (o LogStorageTierPolicyOutput) ToLogStorageTierPolicyOutputWithContext(ctx context.Context) LogStorageTierPolicyOutput {
+ return o
+}
+
+// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+func (o LogStorageTierPolicyOutput) Region() pulumi.StringOutput {
+ return o.ApplyT(func(v *LogStorageTierPolicy) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput)
+}
+
+// Storage tier to set for the account. Valid values are `STANDARD` or `INTELLIGENT_TIERING`.
+func (o LogStorageTierPolicyOutput) StorageTier() pulumi.StringOutput {
+ return o.ApplyT(func(v *LogStorageTierPolicy) pulumi.StringOutput { return v.StorageTier }).(pulumi.StringOutput)
+}
+
+type LogStorageTierPolicyArrayOutput struct{ *pulumi.OutputState }
+
+func (LogStorageTierPolicyArrayOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*[]*LogStorageTierPolicy)(nil)).Elem()
+}
+
+func (o LogStorageTierPolicyArrayOutput) ToLogStorageTierPolicyArrayOutput() LogStorageTierPolicyArrayOutput {
+ return o
+}
+
+func (o LogStorageTierPolicyArrayOutput) ToLogStorageTierPolicyArrayOutputWithContext(ctx context.Context) LogStorageTierPolicyArrayOutput {
+ return o
+}
+
+func (o LogStorageTierPolicyArrayOutput) Index(i pulumi.IntInput) LogStorageTierPolicyOutput {
+ return pulumi.All(o, i).ApplyT(func(vs []interface{}) *LogStorageTierPolicy {
+ return vs[0].([]*LogStorageTierPolicy)[vs[1].(int)]
+ }).(LogStorageTierPolicyOutput)
+}
+
+type LogStorageTierPolicyMapOutput struct{ *pulumi.OutputState }
+
+func (LogStorageTierPolicyMapOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*map[string]*LogStorageTierPolicy)(nil)).Elem()
+}
+
+func (o LogStorageTierPolicyMapOutput) ToLogStorageTierPolicyMapOutput() LogStorageTierPolicyMapOutput {
+ return o
+}
+
+func (o LogStorageTierPolicyMapOutput) ToLogStorageTierPolicyMapOutputWithContext(ctx context.Context) LogStorageTierPolicyMapOutput {
+ return o
+}
+
+func (o LogStorageTierPolicyMapOutput) MapIndex(k pulumi.StringInput) LogStorageTierPolicyOutput {
+ return pulumi.All(o, k).ApplyT(func(vs []interface{}) *LogStorageTierPolicy {
+ return vs[0].(map[string]*LogStorageTierPolicy)[vs[1].(string)]
+ }).(LogStorageTierPolicyOutput)
+}
+
+func init() {
+ pulumi.RegisterInputType(reflect.TypeOf((*LogStorageTierPolicyInput)(nil)).Elem(), &LogStorageTierPolicy{})
+ pulumi.RegisterInputType(reflect.TypeOf((*LogStorageTierPolicyArrayInput)(nil)).Elem(), LogStorageTierPolicyArray{})
+ pulumi.RegisterInputType(reflect.TypeOf((*LogStorageTierPolicyMapInput)(nil)).Elem(), LogStorageTierPolicyMap{})
+ pulumi.RegisterOutputType(LogStorageTierPolicyOutput{})
+ pulumi.RegisterOutputType(LogStorageTierPolicyArrayOutput{})
+ pulumi.RegisterOutputType(LogStorageTierPolicyMapOutput{})
+}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/eipDomainName.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/eipDomainName.go
index 974995485..c46c62530 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/eipDomainName.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/eipDomainName.go
@@ -64,7 +64,7 @@ import (
// Using `pulumi import`, import a static reverse DNS record to an Elastic IP addresses using their association IDs. For example:
//
// ```sh
-// $ pulumi import aws:ec2/eipDomainName:EipDomainName test eipassoc-ab12c345
+// $ pulumi import aws:ec2/eipDomainName:EipDomainName test eipalloc-ab12c345
// ```
type EipDomainName struct {
pulumi.CustomResourceState
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/flowLog.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/flowLog.go
index 05af9d376..29a6acaaa 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/flowLog.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/flowLog.go
@@ -379,6 +379,17 @@ import (
//
// ## Import
//
+// ### Identity Schema
+//
+// #### Required
+//
+// * `id` (String) Flow Log ID.
+//
+// #### Optional
+//
+// * `accountId` (String) AWS Account where this resource is managed.
+// * `region` (String) Region where this resource is managed.
+//
// Using `pulumi import`, import Flow Logs using the `id`. For example:
//
// ```sh
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getCapacityBlockOffering.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getCapacityBlockOffering.go
index 77d011f16..8a7f59a35 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getCapacityBlockOffering.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getCapacityBlockOffering.go
@@ -76,10 +76,8 @@ type GetCapacityBlockOfferingResult struct {
CapacityBlockOfferingId string `pulumi:"capacityBlockOfferingId"`
CapacityDurationHours int `pulumi:"capacityDurationHours"`
// The currency of the payment for the Capacity Block.
- CurrencyCode string `pulumi:"currencyCode"`
- EndDateRange string `pulumi:"endDateRange"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
+ CurrencyCode string `pulumi:"currencyCode"`
+ EndDateRange string `pulumi:"endDateRange"`
InstanceCount int `pulumi:"instanceCount"`
InstanceType string `pulumi:"instanceType"`
Region string `pulumi:"region"`
@@ -157,11 +155,6 @@ func (o GetCapacityBlockOfferingResultOutput) EndDateRange() pulumi.StringOutput
return o.ApplyT(func(v GetCapacityBlockOfferingResult) string { return v.EndDateRange }).(pulumi.StringOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetCapacityBlockOfferingResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetCapacityBlockOfferingResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetCapacityBlockOfferingResultOutput) InstanceCount() pulumi.IntOutput {
return o.ApplyT(func(v GetCapacityBlockOfferingResult) int { return v.InstanceCount }).(pulumi.IntOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getHosts.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getHosts.go
index a588f63a3..7b176e0cd 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getHosts.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getHosts.go
@@ -114,8 +114,6 @@ type GetHostsArgs struct {
// A collection of values returned by getHosts.
type GetHostsResult struct {
Filters []GetHostsFilter `pulumi:"filters"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// List of EC2 Dedicated Host identifiers.
Ids []string `pulumi:"ids"`
OutpostArn *string `pulumi:"outpostArn"`
@@ -167,11 +165,6 @@ func (o GetHostsResultOutput) Filters() GetHostsFilterArrayOutput {
return o.ApplyT(func(v GetHostsResult) []GetHostsFilter { return v.Filters }).(GetHostsFilterArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetHostsResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetHostsResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// List of EC2 Dedicated Host identifiers.
func (o GetHostsResultOutput) Ids() pulumi.StringArrayOutput {
return o.ApplyT(func(v GetHostsResult) []string { return v.Ids }).(pulumi.StringArrayOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getServiceLinkVirtualInterfaces.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getServiceLinkVirtualInterfaces.go
index 152ce0f86..dba2ee326 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getServiceLinkVirtualInterfaces.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getServiceLinkVirtualInterfaces.go
@@ -68,8 +68,6 @@ type GetServiceLinkVirtualInterfacesArgs struct {
// A collection of values returned by getServiceLinkVirtualInterfaces.
type GetServiceLinkVirtualInterfacesResult struct {
Filters []GetServiceLinkVirtualInterfacesFilter `pulumi:"filters"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// List of EC2 Service Link Virtual Interface identifiers.
Ids []string `pulumi:"ids"`
Region string `pulumi:"region"`
@@ -120,11 +118,6 @@ func (o GetServiceLinkVirtualInterfacesResultOutput) Filters() GetServiceLinkVir
}).(GetServiceLinkVirtualInterfacesFilterArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetServiceLinkVirtualInterfacesResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetServiceLinkVirtualInterfacesResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// List of EC2 Service Link Virtual Interface identifiers.
func (o GetServiceLinkVirtualInterfacesResultOutput) Ids() pulumi.StringArrayOutput {
return o.ApplyT(func(v GetServiceLinkVirtualInterfacesResult) []string { return v.Ids }).(pulumi.StringArrayOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getSpotDatafeedSubscription.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getSpotDatafeedSubscription.go
index 48d1fdef7..6d20dfa61 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getSpotDatafeedSubscription.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getSpotDatafeedSubscription.go
@@ -58,8 +58,6 @@ type LookupSpotDatafeedSubscriptionArgs struct {
type LookupSpotDatafeedSubscriptionResult struct {
// The name of the Amazon S3 bucket where the spot instance data feed is located.
Bucket string `pulumi:"bucket"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// The prefix for the data feed files.
Prefix string `pulumi:"prefix"`
Region string `pulumi:"region"`
@@ -104,11 +102,6 @@ func (o LookupSpotDatafeedSubscriptionResultOutput) Bucket() pulumi.StringOutput
return o.ApplyT(func(v LookupSpotDatafeedSubscriptionResult) string { return v.Bucket }).(pulumi.StringOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupSpotDatafeedSubscriptionResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupSpotDatafeedSubscriptionResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// The prefix for the data feed files.
func (o LookupSpotDatafeedSubscriptionResultOutput) Prefix() pulumi.StringOutput {
return o.ApplyT(func(v LookupSpotDatafeedSubscriptionResult) string { return v.Prefix }).(pulumi.StringOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpc.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpc.go
index a1d999a9b..49a9cbe51 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpc.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpc.go
@@ -123,10 +123,15 @@ type LookupVpcResult struct {
// Allowed tenancy of instances launched into the
// selected VPC. May be any of `"default"`, `"dedicated"`, or `"host"`.
InstanceTenancy string `pulumi:"instanceTenancy"`
- // Association ID for the IPv6 CIDR block.
+ // (**Deprecated** use `ipv6CidrBlockAssociations` instead) Association ID for the IPv6 CIDR block.
+ //
+ // Deprecated: ipv6_association_id is deprecated. Use ipv6CidrBlockAssociations instead.
Ipv6AssociationId string `pulumi:"ipv6AssociationId"`
- // IPv6 CIDR block.
- Ipv6CidrBlock string `pulumi:"ipv6CidrBlock"`
+ // IPv6 CIDR block for the association.
+ //
+ // Deprecated: ipv6_cidr_block is deprecated. Use ipv6CidrBlockAssociations instead.
+ Ipv6CidrBlock string `pulumi:"ipv6CidrBlock"`
+ Ipv6CidrBlockAssociations []GetVpcIpv6CidrBlockAssociationType `pulumi:"ipv6CidrBlockAssociations"`
// ID of the main route table associated with this VPC.
MainRouteTableId string `pulumi:"mainRouteTableId"`
// ID of the AWS account that owns the VPC.
@@ -242,16 +247,24 @@ func (o LookupVpcResultOutput) InstanceTenancy() pulumi.StringOutput {
return o.ApplyT(func(v LookupVpcResult) string { return v.InstanceTenancy }).(pulumi.StringOutput)
}
-// Association ID for the IPv6 CIDR block.
+// (**Deprecated** use `ipv6CidrBlockAssociations` instead) Association ID for the IPv6 CIDR block.
+//
+// Deprecated: ipv6_association_id is deprecated. Use ipv6CidrBlockAssociations instead.
func (o LookupVpcResultOutput) Ipv6AssociationId() pulumi.StringOutput {
return o.ApplyT(func(v LookupVpcResult) string { return v.Ipv6AssociationId }).(pulumi.StringOutput)
}
-// IPv6 CIDR block.
+// IPv6 CIDR block for the association.
+//
+// Deprecated: ipv6_cidr_block is deprecated. Use ipv6CidrBlockAssociations instead.
func (o LookupVpcResultOutput) Ipv6CidrBlock() pulumi.StringOutput {
return o.ApplyT(func(v LookupVpcResult) string { return v.Ipv6CidrBlock }).(pulumi.StringOutput)
}
+func (o LookupVpcResultOutput) Ipv6CidrBlockAssociations() GetVpcIpv6CidrBlockAssociationTypeArrayOutput {
+ return o.ApplyT(func(v LookupVpcResult) []GetVpcIpv6CidrBlockAssociationType { return v.Ipv6CidrBlockAssociations }).(GetVpcIpv6CidrBlockAssociationTypeArrayOutput)
+}
+
// ID of the main route table associated with this VPC.
func (o LookupVpcResultOutput) MainRouteTableId() pulumi.StringOutput {
return o.ApplyT(func(v LookupVpcResult) string { return v.MainRouteTableId }).(pulumi.StringOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpcIpams.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpcIpams.go
index 0678ff39b..7bc8cc151 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpcIpams.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpcIpams.go
@@ -133,9 +133,7 @@ type GetVpcIpamsArgs struct {
// A collection of values returned by getVpcIpams.
type GetVpcIpamsResult struct {
Filters []GetVpcIpamsFilter `pulumi:"filters"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- IpamIds []string `pulumi:"ipamIds"`
+ IpamIds []string `pulumi:"ipamIds"`
// List of IPAM resources matching the provided arguments.
Ipams []GetVpcIpamsIpam `pulumi:"ipams"`
Region string `pulumi:"region"`
@@ -185,11 +183,6 @@ func (o GetVpcIpamsResultOutput) Filters() GetVpcIpamsFilterArrayOutput {
return o.ApplyT(func(v GetVpcIpamsResult) []GetVpcIpamsFilter { return v.Filters }).(GetVpcIpamsFilterArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetVpcIpamsResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetVpcIpamsResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetVpcIpamsResultOutput) IpamIds() pulumi.StringArrayOutput {
return o.ApplyT(func(v GetVpcIpamsResult) []string { return v.IpamIds }).(pulumi.StringArrayOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpnConnection.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpnConnection.go
index 87ddebf43..807e75dd9 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpnConnection.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/getVpnConnection.go
@@ -110,8 +110,6 @@ type LookupVpnConnectionResult struct {
Filters []GetVpnConnectionFilter `pulumi:"filters"`
// Current state of the gateway association.
GatewayAssociationState string `pulumi:"gatewayAssociationState"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// (ARN) of the Secrets Manager secret storing the pre-shared key(s) for the VPN connection.
PreSharedKeyArn string `pulumi:"preSharedKeyArn"`
Region string `pulumi:"region"`
@@ -206,11 +204,6 @@ func (o LookupVpnConnectionResultOutput) GatewayAssociationState() pulumi.String
return o.ApplyT(func(v LookupVpnConnectionResult) string { return v.GatewayAssociationState }).(pulumi.StringOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupVpnConnectionResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupVpnConnectionResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// (ARN) of the Secrets Manager secret storing the pre-shared key(s) for the VPN connection.
func (o LookupVpnConnectionResultOutput) PreSharedKeyArn() pulumi.StringOutput {
return o.ApplyT(func(v LookupVpnConnectionResult) string { return v.PreSharedKeyArn }).(pulumi.StringOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes.go
index f26d0e602..6e5106765 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes.go
@@ -17035,6 +17035,8 @@ type LaunchTemplateNetworkInterface struct {
Description *string `pulumi:"description"`
// The integer index of the network interface attachment.
DeviceIndex *int `pulumi:"deviceIndex"`
+ // The number of ENA queues to be created with the instance. Requires an instance type and operating system that support [ENA queue configuration](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ena-queues.html).
+ EnaQueueCount *int `pulumi:"enaQueueCount"`
// Configuration for Elastic Network Adapter (ENA) Express settings. Applies to network interfaces that use the [ena Express](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking-ena-express.html) feature. See details below.
EnaSrdSpecification *LaunchTemplateNetworkInterfaceEnaSrdSpecification `pulumi:"enaSrdSpecification"`
// The type of network interface. To create an Elastic Fabric Adapter (EFA), specify `efa`.
@@ -17093,6 +17095,8 @@ type LaunchTemplateNetworkInterfaceArgs struct {
Description pulumi.StringPtrInput `pulumi:"description"`
// The integer index of the network interface attachment.
DeviceIndex pulumi.IntPtrInput `pulumi:"deviceIndex"`
+ // The number of ENA queues to be created with the instance. Requires an instance type and operating system that support [ENA queue configuration](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ena-queues.html).
+ EnaQueueCount pulumi.IntPtrInput `pulumi:"enaQueueCount"`
// Configuration for Elastic Network Adapter (ENA) Express settings. Applies to network interfaces that use the [ena Express](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking-ena-express.html) feature. See details below.
EnaSrdSpecification LaunchTemplateNetworkInterfaceEnaSrdSpecificationPtrInput `pulumi:"enaSrdSpecification"`
// The type of network interface. To create an Elastic Fabric Adapter (EFA), specify `efa`.
@@ -17210,6 +17214,11 @@ func (o LaunchTemplateNetworkInterfaceOutput) DeviceIndex() pulumi.IntPtrOutput
return o.ApplyT(func(v LaunchTemplateNetworkInterface) *int { return v.DeviceIndex }).(pulumi.IntPtrOutput)
}
+// The number of ENA queues to be created with the instance. Requires an instance type and operating system that support [ENA queue configuration](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ena-queues.html).
+func (o LaunchTemplateNetworkInterfaceOutput) EnaQueueCount() pulumi.IntPtrOutput {
+ return o.ApplyT(func(v LaunchTemplateNetworkInterface) *int { return v.EnaQueueCount }).(pulumi.IntPtrOutput)
+}
+
// Configuration for Elastic Network Adapter (ENA) Express settings. Applies to network interfaces that use the [ena Express](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/enhanced-networking-ena-express.html) feature. See details below.
func (o LaunchTemplateNetworkInterfaceOutput) EnaSrdSpecification() LaunchTemplateNetworkInterfaceEnaSrdSpecificationPtrOutput {
return o.ApplyT(func(v LaunchTemplateNetworkInterface) *LaunchTemplateNetworkInterfaceEnaSrdSpecification {
@@ -54941,6 +54950,7 @@ type GetLaunchTemplateNetworkInterface struct {
DeleteOnTermination *bool `pulumi:"deleteOnTermination"`
Description string `pulumi:"description"`
DeviceIndex int `pulumi:"deviceIndex"`
+ EnaQueueCount int `pulumi:"enaQueueCount"`
InterfaceType string `pulumi:"interfaceType"`
Ipv4AddressCount int `pulumi:"ipv4AddressCount"`
Ipv4Addresses []string `pulumi:"ipv4Addresses"`
@@ -54976,6 +54986,7 @@ type GetLaunchTemplateNetworkInterfaceArgs struct {
DeleteOnTermination pulumi.BoolPtrInput `pulumi:"deleteOnTermination"`
Description pulumi.StringInput `pulumi:"description"`
DeviceIndex pulumi.IntInput `pulumi:"deviceIndex"`
+ EnaQueueCount pulumi.IntInput `pulumi:"enaQueueCount"`
InterfaceType pulumi.StringInput `pulumi:"interfaceType"`
Ipv4AddressCount pulumi.IntInput `pulumi:"ipv4AddressCount"`
Ipv4Addresses pulumi.StringArrayInput `pulumi:"ipv4Addresses"`
@@ -55070,6 +55081,10 @@ func (o GetLaunchTemplateNetworkInterfaceOutput) DeviceIndex() pulumi.IntOutput
return o.ApplyT(func(v GetLaunchTemplateNetworkInterface) int { return v.DeviceIndex }).(pulumi.IntOutput)
}
+func (o GetLaunchTemplateNetworkInterfaceOutput) EnaQueueCount() pulumi.IntOutput {
+ return o.ApplyT(func(v GetLaunchTemplateNetworkInterface) int { return v.EnaQueueCount }).(pulumi.IntOutput)
+}
+
func (o GetLaunchTemplateNetworkInterfaceOutput) InterfaceType() pulumi.StringOutput {
return o.ApplyT(func(v GetLaunchTemplateNetworkInterface) string { return v.InterfaceType }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes1.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes1.go
index 9bd6359b0..0c64b617b 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes1.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ec2/pulumiTypes1.go
@@ -2784,6 +2784,160 @@ func (o GetVpcIpamsIpamOperatingRegionArrayOutput) Index(i pulumi.IntInput) GetV
}).(GetVpcIpamsIpamOperatingRegionOutput)
}
+type GetVpcIpv6CidrBlockAssociationType struct {
+ // Association ID for the IPv4 CIDR block.
+ AssociationId string `pulumi:"associationId"`
+ // The source that allocated the IP address space. Values: `amazon`, `byoip`, `none`.
+ IpSource string `pulumi:"ipSource"`
+ // Indicates whether the address is `public` or `private`.
+ Ipv6AddressAttribute string `pulumi:"ipv6AddressAttribute"`
+ // IPv6 CIDR block for the association.
+ Ipv6CidrBlock string `pulumi:"ipv6CidrBlock"`
+ // Name of IPv6 address pool from which the IPv6 CIDR block is allocated.
+ Ipv6Pool string `pulumi:"ipv6Pool"`
+ // Name of association's network border group.
+ NetworkBorderGroup string `pulumi:"networkBorderGroup"`
+ // Current state of the desired VPC.
+ // Can be either `"pending"` or `"available"`.
+ State string `pulumi:"state"`
+}
+
+// GetVpcIpv6CidrBlockAssociationTypeInput is an input type that accepts GetVpcIpv6CidrBlockAssociationTypeArgs and GetVpcIpv6CidrBlockAssociationTypeOutput values.
+// You can construct a concrete instance of `GetVpcIpv6CidrBlockAssociationTypeInput` via:
+//
+// GetVpcIpv6CidrBlockAssociationTypeArgs{...}
+type GetVpcIpv6CidrBlockAssociationTypeInput interface {
+ pulumi.Input
+
+ ToGetVpcIpv6CidrBlockAssociationTypeOutput() GetVpcIpv6CidrBlockAssociationTypeOutput
+ ToGetVpcIpv6CidrBlockAssociationTypeOutputWithContext(context.Context) GetVpcIpv6CidrBlockAssociationTypeOutput
+}
+
+type GetVpcIpv6CidrBlockAssociationTypeArgs struct {
+ // Association ID for the IPv4 CIDR block.
+ AssociationId pulumi.StringInput `pulumi:"associationId"`
+ // The source that allocated the IP address space. Values: `amazon`, `byoip`, `none`.
+ IpSource pulumi.StringInput `pulumi:"ipSource"`
+ // Indicates whether the address is `public` or `private`.
+ Ipv6AddressAttribute pulumi.StringInput `pulumi:"ipv6AddressAttribute"`
+ // IPv6 CIDR block for the association.
+ Ipv6CidrBlock pulumi.StringInput `pulumi:"ipv6CidrBlock"`
+ // Name of IPv6 address pool from which the IPv6 CIDR block is allocated.
+ Ipv6Pool pulumi.StringInput `pulumi:"ipv6Pool"`
+ // Name of association's network border group.
+ NetworkBorderGroup pulumi.StringInput `pulumi:"networkBorderGroup"`
+ // Current state of the desired VPC.
+ // Can be either `"pending"` or `"available"`.
+ State pulumi.StringInput `pulumi:"state"`
+}
+
+func (GetVpcIpv6CidrBlockAssociationTypeArgs) ElementType() reflect.Type {
+ return reflect.TypeOf((*GetVpcIpv6CidrBlockAssociationType)(nil)).Elem()
+}
+
+func (i GetVpcIpv6CidrBlockAssociationTypeArgs) ToGetVpcIpv6CidrBlockAssociationTypeOutput() GetVpcIpv6CidrBlockAssociationTypeOutput {
+ return i.ToGetVpcIpv6CidrBlockAssociationTypeOutputWithContext(context.Background())
+}
+
+func (i GetVpcIpv6CidrBlockAssociationTypeArgs) ToGetVpcIpv6CidrBlockAssociationTypeOutputWithContext(ctx context.Context) GetVpcIpv6CidrBlockAssociationTypeOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(GetVpcIpv6CidrBlockAssociationTypeOutput)
+}
+
+// GetVpcIpv6CidrBlockAssociationTypeArrayInput is an input type that accepts GetVpcIpv6CidrBlockAssociationTypeArray and GetVpcIpv6CidrBlockAssociationTypeArrayOutput values.
+// You can construct a concrete instance of `GetVpcIpv6CidrBlockAssociationTypeArrayInput` via:
+//
+// GetVpcIpv6CidrBlockAssociationTypeArray{ GetVpcIpv6CidrBlockAssociationTypeArgs{...} }
+type GetVpcIpv6CidrBlockAssociationTypeArrayInput interface {
+ pulumi.Input
+
+ ToGetVpcIpv6CidrBlockAssociationTypeArrayOutput() GetVpcIpv6CidrBlockAssociationTypeArrayOutput
+ ToGetVpcIpv6CidrBlockAssociationTypeArrayOutputWithContext(context.Context) GetVpcIpv6CidrBlockAssociationTypeArrayOutput
+}
+
+type GetVpcIpv6CidrBlockAssociationTypeArray []GetVpcIpv6CidrBlockAssociationTypeInput
+
+func (GetVpcIpv6CidrBlockAssociationTypeArray) ElementType() reflect.Type {
+ return reflect.TypeOf((*[]GetVpcIpv6CidrBlockAssociationType)(nil)).Elem()
+}
+
+func (i GetVpcIpv6CidrBlockAssociationTypeArray) ToGetVpcIpv6CidrBlockAssociationTypeArrayOutput() GetVpcIpv6CidrBlockAssociationTypeArrayOutput {
+ return i.ToGetVpcIpv6CidrBlockAssociationTypeArrayOutputWithContext(context.Background())
+}
+
+func (i GetVpcIpv6CidrBlockAssociationTypeArray) ToGetVpcIpv6CidrBlockAssociationTypeArrayOutputWithContext(ctx context.Context) GetVpcIpv6CidrBlockAssociationTypeArrayOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(GetVpcIpv6CidrBlockAssociationTypeArrayOutput)
+}
+
+type GetVpcIpv6CidrBlockAssociationTypeOutput struct{ *pulumi.OutputState }
+
+func (GetVpcIpv6CidrBlockAssociationTypeOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*GetVpcIpv6CidrBlockAssociationType)(nil)).Elem()
+}
+
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) ToGetVpcIpv6CidrBlockAssociationTypeOutput() GetVpcIpv6CidrBlockAssociationTypeOutput {
+ return o
+}
+
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) ToGetVpcIpv6CidrBlockAssociationTypeOutputWithContext(ctx context.Context) GetVpcIpv6CidrBlockAssociationTypeOutput {
+ return o
+}
+
+// Association ID for the IPv4 CIDR block.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) AssociationId() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.AssociationId }).(pulumi.StringOutput)
+}
+
+// The source that allocated the IP address space. Values: `amazon`, `byoip`, `none`.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) IpSource() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.IpSource }).(pulumi.StringOutput)
+}
+
+// Indicates whether the address is `public` or `private`.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) Ipv6AddressAttribute() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.Ipv6AddressAttribute }).(pulumi.StringOutput)
+}
+
+// IPv6 CIDR block for the association.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) Ipv6CidrBlock() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.Ipv6CidrBlock }).(pulumi.StringOutput)
+}
+
+// Name of IPv6 address pool from which the IPv6 CIDR block is allocated.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) Ipv6Pool() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.Ipv6Pool }).(pulumi.StringOutput)
+}
+
+// Name of association's network border group.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) NetworkBorderGroup() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.NetworkBorderGroup }).(pulumi.StringOutput)
+}
+
+// Current state of the desired VPC.
+// Can be either `"pending"` or `"available"`.
+func (o GetVpcIpv6CidrBlockAssociationTypeOutput) State() pulumi.StringOutput {
+ return o.ApplyT(func(v GetVpcIpv6CidrBlockAssociationType) string { return v.State }).(pulumi.StringOutput)
+}
+
+type GetVpcIpv6CidrBlockAssociationTypeArrayOutput struct{ *pulumi.OutputState }
+
+func (GetVpcIpv6CidrBlockAssociationTypeArrayOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*[]GetVpcIpv6CidrBlockAssociationType)(nil)).Elem()
+}
+
+func (o GetVpcIpv6CidrBlockAssociationTypeArrayOutput) ToGetVpcIpv6CidrBlockAssociationTypeArrayOutput() GetVpcIpv6CidrBlockAssociationTypeArrayOutput {
+ return o
+}
+
+func (o GetVpcIpv6CidrBlockAssociationTypeArrayOutput) ToGetVpcIpv6CidrBlockAssociationTypeArrayOutputWithContext(ctx context.Context) GetVpcIpv6CidrBlockAssociationTypeArrayOutput {
+ return o
+}
+
+func (o GetVpcIpv6CidrBlockAssociationTypeArrayOutput) Index(i pulumi.IntInput) GetVpcIpv6CidrBlockAssociationTypeOutput {
+ return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetVpcIpv6CidrBlockAssociationType {
+ return vs[0].([]GetVpcIpv6CidrBlockAssociationType)[vs[1].(int)]
+ }).(GetVpcIpv6CidrBlockAssociationTypeOutput)
+}
+
type GetVpcPeeringConnectionCidrBlockSet struct {
// Primary CIDR block of the requester VPC of the specific VPC Peering Connection to retrieve.
CidrBlock string `pulumi:"cidrBlock"`
@@ -3994,6 +4148,8 @@ func init() {
pulumi.RegisterInputType(reflect.TypeOf((*GetVpcIpamsIpamArrayInput)(nil)).Elem(), GetVpcIpamsIpamArray{})
pulumi.RegisterInputType(reflect.TypeOf((*GetVpcIpamsIpamOperatingRegionInput)(nil)).Elem(), GetVpcIpamsIpamOperatingRegionArgs{})
pulumi.RegisterInputType(reflect.TypeOf((*GetVpcIpamsIpamOperatingRegionArrayInput)(nil)).Elem(), GetVpcIpamsIpamOperatingRegionArray{})
+ pulumi.RegisterInputType(reflect.TypeOf((*GetVpcIpv6CidrBlockAssociationTypeInput)(nil)).Elem(), GetVpcIpv6CidrBlockAssociationTypeArgs{})
+ pulumi.RegisterInputType(reflect.TypeOf((*GetVpcIpv6CidrBlockAssociationTypeArrayInput)(nil)).Elem(), GetVpcIpv6CidrBlockAssociationTypeArray{})
pulumi.RegisterInputType(reflect.TypeOf((*GetVpcPeeringConnectionCidrBlockSetInput)(nil)).Elem(), GetVpcPeeringConnectionCidrBlockSetArgs{})
pulumi.RegisterInputType(reflect.TypeOf((*GetVpcPeeringConnectionCidrBlockSetArrayInput)(nil)).Elem(), GetVpcPeeringConnectionCidrBlockSetArray{})
pulumi.RegisterInputType(reflect.TypeOf((*GetVpcPeeringConnectionFilterInput)(nil)).Elem(), GetVpcPeeringConnectionFilterArgs{})
@@ -4062,6 +4218,8 @@ func init() {
pulumi.RegisterOutputType(GetVpcIpamsIpamArrayOutput{})
pulumi.RegisterOutputType(GetVpcIpamsIpamOperatingRegionOutput{})
pulumi.RegisterOutputType(GetVpcIpamsIpamOperatingRegionArrayOutput{})
+ pulumi.RegisterOutputType(GetVpcIpv6CidrBlockAssociationTypeOutput{})
+ pulumi.RegisterOutputType(GetVpcIpv6CidrBlockAssociationTypeArrayOutput{})
pulumi.RegisterOutputType(GetVpcPeeringConnectionCidrBlockSetOutput{})
pulumi.RegisterOutputType(GetVpcPeeringConnectionCidrBlockSetArrayOutput{})
pulumi.RegisterOutputType(GetVpcPeeringConnectionFilterOutput{})
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecs/getClusters.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecs/getClusters.go
index e5e8f6001..03267ba73 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecs/getClusters.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecs/getClusters.go
@@ -58,9 +58,7 @@ type GetClustersArgs struct {
type GetClustersResult struct {
// List of ECS cluster ARNs associated with the account.
ClusterArns []string `pulumi:"clusterArns"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- Region string `pulumi:"region"`
+ Region string `pulumi:"region"`
}
func GetClustersOutput(ctx *pulumi.Context, args GetClustersOutputArgs, opts ...pulumi.InvokeOption) GetClustersResultOutput {
@@ -102,11 +100,6 @@ func (o GetClustersResultOutput) ClusterArns() pulumi.StringArrayOutput {
return o.ApplyT(func(v GetClustersResult) []string { return v.ClusterArns }).(pulumi.StringArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetClustersResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetClustersResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetClustersResultOutput) Region() pulumi.StringOutput {
return o.ApplyT(func(v GetClustersResult) string { return v.Region }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getAccessPolicies.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getAccessPolicies.go
new file mode 100644
index 000000000..2cb821f03
--- /dev/null
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getAccessPolicies.go
@@ -0,0 +1,87 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package eks
+
+import (
+ "context"
+ "reflect"
+
+ "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/internal"
+ "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// Data source for managing AWS EKS (Elastic Kubernetes) Access Policies.
+//
+// ## Example Usage
+//
+// ### Basic Usage
+func GetAccessPolicies(ctx *pulumi.Context, args *GetAccessPoliciesArgs, opts ...pulumi.InvokeOption) (*GetAccessPoliciesResult, error) {
+ opts = internal.PkgInvokeDefaultOpts(opts)
+ var rv GetAccessPoliciesResult
+ err := ctx.Invoke("aws:eks/getAccessPolicies:getAccessPolicies", args, &rv, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return &rv, nil
+}
+
+// A collection of arguments for invoking getAccessPolicies.
+type GetAccessPoliciesArgs struct {
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region *string `pulumi:"region"`
+}
+
+// A collection of values returned by getAccessPolicies.
+type GetAccessPoliciesResult struct {
+ // List of available access policies.
+ AccessPolicies []GetAccessPoliciesAccessPolicy `pulumi:"accessPolicies"`
+ Region string `pulumi:"region"`
+}
+
+func GetAccessPoliciesOutput(ctx *pulumi.Context, args GetAccessPoliciesOutputArgs, opts ...pulumi.InvokeOption) GetAccessPoliciesResultOutput {
+ return pulumi.ToOutputWithContext(ctx.Context(), args).
+ ApplyT(func(v interface{}) (GetAccessPoliciesResultOutput, error) {
+ args := v.(GetAccessPoliciesArgs)
+ options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)}
+ return ctx.InvokeOutput("aws:eks/getAccessPolicies:getAccessPolicies", args, GetAccessPoliciesResultOutput{}, options).(GetAccessPoliciesResultOutput), nil
+ }).(GetAccessPoliciesResultOutput)
+}
+
+// A collection of arguments for invoking getAccessPolicies.
+type GetAccessPoliciesOutputArgs struct {
+ // Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
+ Region pulumi.StringPtrInput `pulumi:"region"`
+}
+
+func (GetAccessPoliciesOutputArgs) ElementType() reflect.Type {
+ return reflect.TypeOf((*GetAccessPoliciesArgs)(nil)).Elem()
+}
+
+// A collection of values returned by getAccessPolicies.
+type GetAccessPoliciesResultOutput struct{ *pulumi.OutputState }
+
+func (GetAccessPoliciesResultOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*GetAccessPoliciesResult)(nil)).Elem()
+}
+
+func (o GetAccessPoliciesResultOutput) ToGetAccessPoliciesResultOutput() GetAccessPoliciesResultOutput {
+ return o
+}
+
+func (o GetAccessPoliciesResultOutput) ToGetAccessPoliciesResultOutputWithContext(ctx context.Context) GetAccessPoliciesResultOutput {
+ return o
+}
+
+// List of available access policies.
+func (o GetAccessPoliciesResultOutput) AccessPolicies() GetAccessPoliciesAccessPolicyArrayOutput {
+ return o.ApplyT(func(v GetAccessPoliciesResult) []GetAccessPoliciesAccessPolicy { return v.AccessPolicies }).(GetAccessPoliciesAccessPolicyArrayOutput)
+}
+
+func (o GetAccessPoliciesResultOutput) Region() pulumi.StringOutput {
+ return o.ApplyT(func(v GetAccessPoliciesResult) string { return v.Region }).(pulumi.StringOutput)
+}
+
+func init() {
+ pulumi.RegisterOutputType(GetAccessPoliciesResultOutput{})
+}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getClusterVersions.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getClusterVersions.go
index 3fe481fc7..b71dd0459 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getClusterVersions.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/getClusterVersions.go
@@ -103,10 +103,8 @@ type GetClusterVersionsResult struct {
ClusterVersions []GetClusterVersionsClusterVersion `pulumi:"clusterVersions"`
ClusterVersionsOnlies []string `pulumi:"clusterVersionsOnlies"`
DefaultOnly *bool `pulumi:"defaultOnly"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- IncludeAll *bool `pulumi:"includeAll"`
- Region string `pulumi:"region"`
+ IncludeAll *bool `pulumi:"includeAll"`
+ Region string `pulumi:"region"`
// Status of the EKS cluster version.
VersionStatus *string `pulumi:"versionStatus"`
}
@@ -174,11 +172,6 @@ func (o GetClusterVersionsResultOutput) DefaultOnly() pulumi.BoolPtrOutput {
return o.ApplyT(func(v GetClusterVersionsResult) *bool { return v.DefaultOnly }).(pulumi.BoolPtrOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetClusterVersionsResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetClusterVersionsResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetClusterVersionsResultOutput) IncludeAll() pulumi.BoolPtrOutput {
return o.ApplyT(func(v GetClusterVersionsResult) *bool { return v.IncludeAll }).(pulumi.BoolPtrOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/podIdentityAssociation.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/podIdentityAssociation.go
index 041713d52..f69667124 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/podIdentityAssociation.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/podIdentityAssociation.go
@@ -24,6 +24,55 @@ import (
//
// ## Example Usage
//
+// ### With Inline Session Policy
+//
+// ```go
+// package main
+//
+// import (
+//
+// "encoding/json"
+//
+// "github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks"
+// "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+//
+// )
+//
+// func main() {
+// pulumi.Run(func(ctx *pulumi.Context) error {
+// tmpJSON0, err := json.Marshal(map[string]interface{}{
+// "Version": "2012-10-17",
+// "Statement": []map[string]interface{}{
+// map[string]interface{}{
+// "Effect": "Allow",
+// "Action": []string{
+// "s3:GetObject",
+// },
+// "Resource": "arn:aws:s3:::my-bucket/*",
+// },
+// },
+// })
+// if err != nil {
+// return err
+// }
+// json0 := string(tmpJSON0)
+// _, err = eks.NewPodIdentityAssociation(ctx, "example", &eks.PodIdentityAssociationArgs{
+// ClusterName: pulumi.Any(exampleAwsEksCluster.Name),
+// Namespace: pulumi.String("example"),
+// ServiceAccount: pulumi.String("example-sa"),
+// RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
+// DisableSessionTags: pulumi.Bool(true),
+// Policy: pulumi.String(json0),
+// })
+// if err != nil {
+// return err
+// }
+// return nil
+// })
+// }
+//
+// ```
+//
// ### Basic Usage
//
// ```go
@@ -118,12 +167,14 @@ type PodIdentityAssociation struct {
AssociationId pulumi.StringOutput `pulumi:"associationId"`
// The name of the cluster to create the association in.
ClusterName pulumi.StringOutput `pulumi:"clusterName"`
- // Disable the tags that are automatically added to role session by Amazon EKS.
+ // Disable the tags that are automatically added to role session by Amazon EKS. Must be set to `true` when `policy` is specified.
DisableSessionTags pulumi.BoolOutput `pulumi:"disableSessionTags"`
// The unique identifier for this association for a target IAM role. You put this value in the trust policy of the target role, in a Condition to match the sts.ExternalId.
ExternalId pulumi.StringOutput `pulumi:"externalId"`
// The name of the Kubernetes namespace inside the cluster to create the association in. The service account and the pods that use the service account must be in this namespace.
Namespace pulumi.StringOutput `pulumi:"namespace"`
+ // An IAM policy in JSON format (as an escaped string) that applies additional restrictions to this Pod Identity association beyond the IAM policies attached to the IAM role. The effective permissions are the intersection of the role's policies and this policy, allowing you to enforce least privilege across multiple associations that share the same role. Requires `disableSessionTags = true`.
+ Policy pulumi.StringPtrOutput `pulumi:"policy"`
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region pulumi.StringOutput `pulumi:"region"`
// The Amazon Resource Name (ARN) of the IAM role to associate with the service account. The EKS Pod Identity agent manages credentials to assume this role for applications in the containers in the pods that use this service account.
@@ -188,12 +239,14 @@ type podIdentityAssociationState struct {
AssociationId *string `pulumi:"associationId"`
// The name of the cluster to create the association in.
ClusterName *string `pulumi:"clusterName"`
- // Disable the tags that are automatically added to role session by Amazon EKS.
+ // Disable the tags that are automatically added to role session by Amazon EKS. Must be set to `true` when `policy` is specified.
DisableSessionTags *bool `pulumi:"disableSessionTags"`
// The unique identifier for this association for a target IAM role. You put this value in the trust policy of the target role, in a Condition to match the sts.ExternalId.
ExternalId *string `pulumi:"externalId"`
// The name of the Kubernetes namespace inside the cluster to create the association in. The service account and the pods that use the service account must be in this namespace.
Namespace *string `pulumi:"namespace"`
+ // An IAM policy in JSON format (as an escaped string) that applies additional restrictions to this Pod Identity association beyond the IAM policies attached to the IAM role. The effective permissions are the intersection of the role's policies and this policy, allowing you to enforce least privilege across multiple associations that share the same role. Requires `disableSessionTags = true`.
+ Policy *string `pulumi:"policy"`
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region *string `pulumi:"region"`
// The Amazon Resource Name (ARN) of the IAM role to associate with the service account. The EKS Pod Identity agent manages credentials to assume this role for applications in the containers in the pods that use this service account.
@@ -217,12 +270,14 @@ type PodIdentityAssociationState struct {
AssociationId pulumi.StringPtrInput
// The name of the cluster to create the association in.
ClusterName pulumi.StringPtrInput
- // Disable the tags that are automatically added to role session by Amazon EKS.
+ // Disable the tags that are automatically added to role session by Amazon EKS. Must be set to `true` when `policy` is specified.
DisableSessionTags pulumi.BoolPtrInput
// The unique identifier for this association for a target IAM role. You put this value in the trust policy of the target role, in a Condition to match the sts.ExternalId.
ExternalId pulumi.StringPtrInput
// The name of the Kubernetes namespace inside the cluster to create the association in. The service account and the pods that use the service account must be in this namespace.
Namespace pulumi.StringPtrInput
+ // An IAM policy in JSON format (as an escaped string) that applies additional restrictions to this Pod Identity association beyond the IAM policies attached to the IAM role. The effective permissions are the intersection of the role's policies and this policy, allowing you to enforce least privilege across multiple associations that share the same role. Requires `disableSessionTags = true`.
+ Policy pulumi.StringPtrInput
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region pulumi.StringPtrInput
// The Amazon Resource Name (ARN) of the IAM role to associate with the service account. The EKS Pod Identity agent manages credentials to assume this role for applications in the containers in the pods that use this service account.
@@ -246,10 +301,12 @@ func (PodIdentityAssociationState) ElementType() reflect.Type {
type podIdentityAssociationArgs struct {
// The name of the cluster to create the association in.
ClusterName string `pulumi:"clusterName"`
- // Disable the tags that are automatically added to role session by Amazon EKS.
+ // Disable the tags that are automatically added to role session by Amazon EKS. Must be set to `true` when `policy` is specified.
DisableSessionTags *bool `pulumi:"disableSessionTags"`
// The name of the Kubernetes namespace inside the cluster to create the association in. The service account and the pods that use the service account must be in this namespace.
Namespace string `pulumi:"namespace"`
+ // An IAM policy in JSON format (as an escaped string) that applies additional restrictions to this Pod Identity association beyond the IAM policies attached to the IAM role. The effective permissions are the intersection of the role's policies and this policy, allowing you to enforce least privilege across multiple associations that share the same role. Requires `disableSessionTags = true`.
+ Policy *string `pulumi:"policy"`
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region *string `pulumi:"region"`
// The Amazon Resource Name (ARN) of the IAM role to associate with the service account. The EKS Pod Identity agent manages credentials to assume this role for applications in the containers in the pods that use this service account.
@@ -268,10 +325,12 @@ type podIdentityAssociationArgs struct {
type PodIdentityAssociationArgs struct {
// The name of the cluster to create the association in.
ClusterName pulumi.StringInput
- // Disable the tags that are automatically added to role session by Amazon EKS.
+ // Disable the tags that are automatically added to role session by Amazon EKS. Must be set to `true` when `policy` is specified.
DisableSessionTags pulumi.BoolPtrInput
// The name of the Kubernetes namespace inside the cluster to create the association in. The service account and the pods that use the service account must be in this namespace.
Namespace pulumi.StringInput
+ // An IAM policy in JSON format (as an escaped string) that applies additional restrictions to this Pod Identity association beyond the IAM policies attached to the IAM role. The effective permissions are the intersection of the role's policies and this policy, allowing you to enforce least privilege across multiple associations that share the same role. Requires `disableSessionTags = true`.
+ Policy pulumi.StringPtrInput
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
Region pulumi.StringPtrInput
// The Amazon Resource Name (ARN) of the IAM role to associate with the service account. The EKS Pod Identity agent manages credentials to assume this role for applications in the containers in the pods that use this service account.
@@ -388,7 +447,7 @@ func (o PodIdentityAssociationOutput) ClusterName() pulumi.StringOutput {
return o.ApplyT(func(v *PodIdentityAssociation) pulumi.StringOutput { return v.ClusterName }).(pulumi.StringOutput)
}
-// Disable the tags that are automatically added to role session by Amazon EKS.
+// Disable the tags that are automatically added to role session by Amazon EKS. Must be set to `true` when `policy` is specified.
func (o PodIdentityAssociationOutput) DisableSessionTags() pulumi.BoolOutput {
return o.ApplyT(func(v *PodIdentityAssociation) pulumi.BoolOutput { return v.DisableSessionTags }).(pulumi.BoolOutput)
}
@@ -403,6 +462,11 @@ func (o PodIdentityAssociationOutput) Namespace() pulumi.StringOutput {
return o.ApplyT(func(v *PodIdentityAssociation) pulumi.StringOutput { return v.Namespace }).(pulumi.StringOutput)
}
+// An IAM policy in JSON format (as an escaped string) that applies additional restrictions to this Pod Identity association beyond the IAM policies attached to the IAM role. The effective permissions are the intersection of the role's policies and this policy, allowing you to enforce least privilege across multiple associations that share the same role. Requires `disableSessionTags = true`.
+func (o PodIdentityAssociationOutput) Policy() pulumi.StringPtrOutput {
+ return o.ApplyT(func(v *PodIdentityAssociation) pulumi.StringPtrOutput { return v.Policy }).(pulumi.StringPtrOutput)
+}
+
// Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.
func (o PodIdentityAssociationOutput) Region() pulumi.StringOutput {
return o.ApplyT(func(v *PodIdentityAssociation) pulumi.StringOutput { return v.Region }).(pulumi.StringOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/pulumiTypes.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/pulumiTypes.go
index 980a287d1..27e195fb6 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/pulumiTypes.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/eks/pulumiTypes.go
@@ -6645,6 +6645,112 @@ func (o NodeGroupWarmPoolConfigPtrOutput) ReuseOnScaleIn() pulumi.BoolPtrOutput
}).(pulumi.BoolPtrOutput)
}
+type GetAccessPoliciesAccessPolicy struct {
+ // ARN of the access policy.
+ Arn string `pulumi:"arn"`
+ // Name of the access policy.
+ Name string `pulumi:"name"`
+}
+
+// GetAccessPoliciesAccessPolicyInput is an input type that accepts GetAccessPoliciesAccessPolicyArgs and GetAccessPoliciesAccessPolicyOutput values.
+// You can construct a concrete instance of `GetAccessPoliciesAccessPolicyInput` via:
+//
+// GetAccessPoliciesAccessPolicyArgs{...}
+type GetAccessPoliciesAccessPolicyInput interface {
+ pulumi.Input
+
+ ToGetAccessPoliciesAccessPolicyOutput() GetAccessPoliciesAccessPolicyOutput
+ ToGetAccessPoliciesAccessPolicyOutputWithContext(context.Context) GetAccessPoliciesAccessPolicyOutput
+}
+
+type GetAccessPoliciesAccessPolicyArgs struct {
+ // ARN of the access policy.
+ Arn pulumi.StringInput `pulumi:"arn"`
+ // Name of the access policy.
+ Name pulumi.StringInput `pulumi:"name"`
+}
+
+func (GetAccessPoliciesAccessPolicyArgs) ElementType() reflect.Type {
+ return reflect.TypeOf((*GetAccessPoliciesAccessPolicy)(nil)).Elem()
+}
+
+func (i GetAccessPoliciesAccessPolicyArgs) ToGetAccessPoliciesAccessPolicyOutput() GetAccessPoliciesAccessPolicyOutput {
+ return i.ToGetAccessPoliciesAccessPolicyOutputWithContext(context.Background())
+}
+
+func (i GetAccessPoliciesAccessPolicyArgs) ToGetAccessPoliciesAccessPolicyOutputWithContext(ctx context.Context) GetAccessPoliciesAccessPolicyOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(GetAccessPoliciesAccessPolicyOutput)
+}
+
+// GetAccessPoliciesAccessPolicyArrayInput is an input type that accepts GetAccessPoliciesAccessPolicyArray and GetAccessPoliciesAccessPolicyArrayOutput values.
+// You can construct a concrete instance of `GetAccessPoliciesAccessPolicyArrayInput` via:
+//
+// GetAccessPoliciesAccessPolicyArray{ GetAccessPoliciesAccessPolicyArgs{...} }
+type GetAccessPoliciesAccessPolicyArrayInput interface {
+ pulumi.Input
+
+ ToGetAccessPoliciesAccessPolicyArrayOutput() GetAccessPoliciesAccessPolicyArrayOutput
+ ToGetAccessPoliciesAccessPolicyArrayOutputWithContext(context.Context) GetAccessPoliciesAccessPolicyArrayOutput
+}
+
+type GetAccessPoliciesAccessPolicyArray []GetAccessPoliciesAccessPolicyInput
+
+func (GetAccessPoliciesAccessPolicyArray) ElementType() reflect.Type {
+ return reflect.TypeOf((*[]GetAccessPoliciesAccessPolicy)(nil)).Elem()
+}
+
+func (i GetAccessPoliciesAccessPolicyArray) ToGetAccessPoliciesAccessPolicyArrayOutput() GetAccessPoliciesAccessPolicyArrayOutput {
+ return i.ToGetAccessPoliciesAccessPolicyArrayOutputWithContext(context.Background())
+}
+
+func (i GetAccessPoliciesAccessPolicyArray) ToGetAccessPoliciesAccessPolicyArrayOutputWithContext(ctx context.Context) GetAccessPoliciesAccessPolicyArrayOutput {
+ return pulumi.ToOutputWithContext(ctx, i).(GetAccessPoliciesAccessPolicyArrayOutput)
+}
+
+type GetAccessPoliciesAccessPolicyOutput struct{ *pulumi.OutputState }
+
+func (GetAccessPoliciesAccessPolicyOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*GetAccessPoliciesAccessPolicy)(nil)).Elem()
+}
+
+func (o GetAccessPoliciesAccessPolicyOutput) ToGetAccessPoliciesAccessPolicyOutput() GetAccessPoliciesAccessPolicyOutput {
+ return o
+}
+
+func (o GetAccessPoliciesAccessPolicyOutput) ToGetAccessPoliciesAccessPolicyOutputWithContext(ctx context.Context) GetAccessPoliciesAccessPolicyOutput {
+ return o
+}
+
+// ARN of the access policy.
+func (o GetAccessPoliciesAccessPolicyOutput) Arn() pulumi.StringOutput {
+ return o.ApplyT(func(v GetAccessPoliciesAccessPolicy) string { return v.Arn }).(pulumi.StringOutput)
+}
+
+// Name of the access policy.
+func (o GetAccessPoliciesAccessPolicyOutput) Name() pulumi.StringOutput {
+ return o.ApplyT(func(v GetAccessPoliciesAccessPolicy) string { return v.Name }).(pulumi.StringOutput)
+}
+
+type GetAccessPoliciesAccessPolicyArrayOutput struct{ *pulumi.OutputState }
+
+func (GetAccessPoliciesAccessPolicyArrayOutput) ElementType() reflect.Type {
+ return reflect.TypeOf((*[]GetAccessPoliciesAccessPolicy)(nil)).Elem()
+}
+
+func (o GetAccessPoliciesAccessPolicyArrayOutput) ToGetAccessPoliciesAccessPolicyArrayOutput() GetAccessPoliciesAccessPolicyArrayOutput {
+ return o
+}
+
+func (o GetAccessPoliciesAccessPolicyArrayOutput) ToGetAccessPoliciesAccessPolicyArrayOutputWithContext(ctx context.Context) GetAccessPoliciesAccessPolicyArrayOutput {
+ return o
+}
+
+func (o GetAccessPoliciesAccessPolicyArrayOutput) Index(i pulumi.IntInput) GetAccessPoliciesAccessPolicyOutput {
+ return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetAccessPoliciesAccessPolicy {
+ return vs[0].([]GetAccessPoliciesAccessPolicy)[vs[1].(int)]
+ }).(GetAccessPoliciesAccessPolicyOutput)
+}
+
type GetAddonPodIdentityAssociation struct {
// ARN of the IAM role associated with the EKS add-on.
RoleArn string `pulumi:"roleArn"`
@@ -9874,6 +9980,8 @@ func init() {
pulumi.RegisterInputType(reflect.TypeOf((*NodeGroupUpdateConfigPtrInput)(nil)).Elem(), NodeGroupUpdateConfigArgs{})
pulumi.RegisterInputType(reflect.TypeOf((*NodeGroupWarmPoolConfigInput)(nil)).Elem(), NodeGroupWarmPoolConfigArgs{})
pulumi.RegisterInputType(reflect.TypeOf((*NodeGroupWarmPoolConfigPtrInput)(nil)).Elem(), NodeGroupWarmPoolConfigArgs{})
+ pulumi.RegisterInputType(reflect.TypeOf((*GetAccessPoliciesAccessPolicyInput)(nil)).Elem(), GetAccessPoliciesAccessPolicyArgs{})
+ pulumi.RegisterInputType(reflect.TypeOf((*GetAccessPoliciesAccessPolicyArrayInput)(nil)).Elem(), GetAccessPoliciesAccessPolicyArray{})
pulumi.RegisterInputType(reflect.TypeOf((*GetAddonPodIdentityAssociationInput)(nil)).Elem(), GetAddonPodIdentityAssociationArgs{})
pulumi.RegisterInputType(reflect.TypeOf((*GetAddonPodIdentityAssociationArrayInput)(nil)).Elem(), GetAddonPodIdentityAssociationArray{})
pulumi.RegisterInputType(reflect.TypeOf((*GetClusterAccessConfigInput)(nil)).Elem(), GetClusterAccessConfigArgs{})
@@ -10017,6 +10125,8 @@ func init() {
pulumi.RegisterOutputType(NodeGroupUpdateConfigPtrOutput{})
pulumi.RegisterOutputType(NodeGroupWarmPoolConfigOutput{})
pulumi.RegisterOutputType(NodeGroupWarmPoolConfigPtrOutput{})
+ pulumi.RegisterOutputType(GetAccessPoliciesAccessPolicyOutput{})
+ pulumi.RegisterOutputType(GetAccessPoliciesAccessPolicyArrayOutput{})
pulumi.RegisterOutputType(GetAddonPodIdentityAssociationOutput{})
pulumi.RegisterOutputType(GetAddonPodIdentityAssociationArrayOutput{})
pulumi.RegisterOutputType(GetClusterAccessConfigOutput{})
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getOutboundWebIdentityFederation.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getOutboundWebIdentityFederation.go
index 60d09f571..cf25a068f 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getOutboundWebIdentityFederation.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getOutboundWebIdentityFederation.go
@@ -48,8 +48,6 @@ func LookupOutboundWebIdentityFederation(ctx *pulumi.Context, opts ...pulumi.Inv
// A collection of values returned by getOutboundWebIdentityFederation.
type LookupOutboundWebIdentityFederationResult struct {
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// A unique issuer URL for your AWS account that hosts the OpenID Connect (OIDC) discovery endpoints.
IssuerIdentifier string `pulumi:"issuerIdentifier"`
}
@@ -76,11 +74,6 @@ func (o LookupOutboundWebIdentityFederationResultOutput) ToLookupOutboundWebIden
return o
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupOutboundWebIdentityFederationResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupOutboundWebIdentityFederationResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// A unique issuer URL for your AWS account that hosts the OpenID Connect (OIDC) discovery endpoints.
func (o LookupOutboundWebIdentityFederationResultOutput) IssuerIdentifier() pulumi.StringOutput {
return o.ApplyT(func(v LookupOutboundWebIdentityFederationResult) string { return v.IssuerIdentifier }).(pulumi.StringOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getPrincipalPolicySimulation.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getPrincipalPolicySimulation.go
index 4b735929f..2f1406653 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getPrincipalPolicySimulation.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getPrincipalPolicySimulation.go
@@ -153,10 +153,8 @@ import (
// }
// accountAccess, err := s3.NewBucketPolicy(ctx, "account_access", &s3.BucketPolicyArgs{
// Bucket: exampleBucket.Bucket,
-// Policy: pulumi.All(exampleBucket.Arn, exampleBucket.Arn).ApplyT(func(_args []interface{}) (string, error) {
-// exampleBucketArn := _args[0].(string)
-// exampleBucketArn1 := _args[1].(string)
-// var _zero string
+// Policy: exampleBucket.Arn.ApplyT(func(arn string) (pulumi.String, error) {
+// var _zero pulumi.String
// tmpJSON1, err := json.Marshal(map[string]interface{}{
// "Version": "2012-10-17",
// "Statement": []map[string]interface{}{
@@ -167,8 +165,8 @@ import (
// "AWS": current.AccountId,
// },
// "Resource": []string{
-// exampleBucketArn,
-// fmt.Sprintf("%v/*", exampleBucketArn1),
+// arn,
+// fmt.Sprintf("%v/*", arn),
// },
// },
// },
@@ -177,7 +175,7 @@ import (
// return _zero, err
// }
// json1 := string(tmpJSON1)
-// return json1, nil
+// return pulumi.String(json1), nil
// }).(pulumi.StringOutput),
// })
// if err != nil {
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicies.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicies.go
index e5ce60a97..b538dd01e 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicies.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicies.go
@@ -56,8 +56,6 @@ type GetRolePoliciesArgs struct {
// A collection of values returned by getRolePolicies.
type GetRolePoliciesResult struct {
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// Set of inline policy names associated with the role.
PolicyNames []string `pulumi:"policyNames"`
RoleName string `pulumi:"roleName"`
@@ -97,11 +95,6 @@ func (o GetRolePoliciesResultOutput) ToGetRolePoliciesResultOutputWithContext(ct
return o
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetRolePoliciesResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetRolePoliciesResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// Set of inline policy names associated with the role.
func (o GetRolePoliciesResultOutput) PolicyNames() pulumi.StringArrayOutput {
return o.ApplyT(func(v GetRolePoliciesResult) []string { return v.PolicyNames }).(pulumi.StringArrayOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicyAttachments.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicyAttachments.go
index da62612e5..68d962e91 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicyAttachments.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/iam/getRolePolicyAttachments.go
@@ -64,10 +64,8 @@ type GetRolePolicyAttachmentsArgs struct {
type GetRolePolicyAttachmentsResult struct {
// List of attached managed policies. See below.
AttachedPolicies []GetRolePolicyAttachmentsAttachedPolicy `pulumi:"attachedPolicies"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- PathPrefix *string `pulumi:"pathPrefix"`
- RoleName string `pulumi:"roleName"`
+ PathPrefix *string `pulumi:"pathPrefix"`
+ RoleName string `pulumi:"roleName"`
}
func GetRolePolicyAttachmentsOutput(ctx *pulumi.Context, args GetRolePolicyAttachmentsOutputArgs, opts ...pulumi.InvokeOption) GetRolePolicyAttachmentsResultOutput {
@@ -115,11 +113,6 @@ func (o GetRolePolicyAttachmentsResultOutput) AttachedPolicies() GetRolePolicyAt
}).(GetRolePolicyAttachmentsAttachedPolicyArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetRolePolicyAttachmentsResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetRolePolicyAttachmentsResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetRolePolicyAttachmentsResultOutput) PathPrefix() pulumi.StringPtrOutput {
return o.ApplyT(func(v GetRolePolicyAttachmentsResult) *string { return v.PathPrefix }).(pulumi.StringPtrOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/internal/pulumiUtilities.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/internal/pulumiUtilities.go
index 226e23f50..3a466b006 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/internal/pulumiUtilities.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/internal/pulumiUtilities.go
@@ -165,7 +165,7 @@ func callPlainInner(
func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption {
defaults := []pulumi.ResourceOption{}
- version := semver.MustParse("7.39.0")
+ version := semver.MustParse("7.40.0")
if !version.Equals(semver.Version{}) {
defaults = append(defaults, pulumi.Version(version.String()))
}
@@ -176,7 +176,7 @@ func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOptio
func PkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption {
defaults := []pulumi.InvokeOption{}
- version := semver.MustParse("7.39.0")
+ version := semver.MustParse("7.40.0")
if !version.Equals(semver.Version{}) {
defaults = append(defaults, pulumi.Version(version.String()))
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb/getListenerRule.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb/getListenerRule.go
index 6e7bb7e85..bb56f6fa6 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb/getListenerRule.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lb/getListenerRule.go
@@ -116,12 +116,10 @@ type LookupListenerRuleResult struct {
Arn string `pulumi:"arn"`
// Set of conditions associated with the rule.
// Detailed below.
- Conditions []GetListenerRuleCondition `pulumi:"conditions"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- ListenerArn string `pulumi:"listenerArn"`
- Priority int `pulumi:"priority"`
- Region string `pulumi:"region"`
+ Conditions []GetListenerRuleCondition `pulumi:"conditions"`
+ ListenerArn string `pulumi:"listenerArn"`
+ Priority int `pulumi:"priority"`
+ Region string `pulumi:"region"`
// Tags assigned to the Listener Rule.
Tags map[string]string `pulumi:"tags"`
// Block for transform to apply to requests that match this rule. Detailed below.
@@ -196,11 +194,6 @@ func (o LookupListenerRuleResultOutput) Conditions() GetListenerRuleConditionArr
return o.ApplyT(func(v LookupListenerRuleResult) []GetListenerRuleCondition { return v.Conditions }).(GetListenerRuleConditionArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupListenerRuleResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupListenerRuleResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o LookupListenerRuleResultOutput) ListenerArn() pulumi.StringOutput {
return o.ApplyT(func(v LookupListenerRuleResult) string { return v.ListenerArn }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/pulumi-plugin.json
index aa395d4fd..6af2bd8b1 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "aws",
- "version": "7.39.0"
+ "version": "7.40.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getAccessPoint.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getAccessPoint.go
index f126b2272..e0e75d07b 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getAccessPoint.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getAccessPoint.go
@@ -75,9 +75,7 @@ type LookupAccessPointResult struct {
DataSourceType string `pulumi:"dataSourceType"`
// VPC endpoint for the access point.
Endpoints map[string]string `pulumi:"endpoints"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- Name string `pulumi:"name"`
+ Name string `pulumi:"name"`
// Indicates whether the access point allows access from the public Internet.
NetworkOrigin string `pulumi:"networkOrigin"`
// `PublicAccessBlock` configuration for the access point.
@@ -166,11 +164,6 @@ func (o LookupAccessPointResultOutput) Endpoints() pulumi.StringMapOutput {
return o.ApplyT(func(v LookupAccessPointResult) map[string]string { return v.Endpoints }).(pulumi.StringMapOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupAccessPointResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupAccessPointResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o LookupAccessPointResultOutput) Name() pulumi.StringOutput {
return o.ApplyT(func(v LookupAccessPointResult) string { return v.Name }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketNotification.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketNotification.go
index 99a3f0932..6d862a41b 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketNotification.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketNotification.go
@@ -177,8 +177,6 @@ type LookupBucketNotificationResult struct {
Bucket string `pulumi:"bucket"`
// Whether Amazon EventBridge notifications are enabled on this bucket.
Eventbridge bool `pulumi:"eventbridge"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// List of Lambda function notification configurations. See `lambdaFunction` below.
LambdaFunctions []GetBucketNotificationLambdaFunction `pulumi:"lambdaFunctions"`
// List of SQS queue notification configurations. See `queue` below.
@@ -233,11 +231,6 @@ func (o LookupBucketNotificationResultOutput) Eventbridge() pulumi.BoolOutput {
return o.ApplyT(func(v LookupBucketNotificationResult) bool { return v.Eventbridge }).(pulumi.BoolOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupBucketNotificationResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupBucketNotificationResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// List of Lambda function notification configurations. See `lambdaFunction` below.
func (o LookupBucketNotificationResultOutput) LambdaFunctions() GetBucketNotificationLambdaFunctionArrayOutput {
return o.ApplyT(func(v LookupBucketNotificationResult) []GetBucketNotificationLambdaFunction { return v.LambdaFunctions }).(GetBucketNotificationLambdaFunctionArrayOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketObjectLockConfiguration.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketObjectLockConfiguration.go
index 481d45ee3..c4f9414c5 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketObjectLockConfiguration.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketObjectLockConfiguration.go
@@ -66,8 +66,6 @@ type LookupBucketObjectLockConfigurationArgs struct {
type LookupBucketObjectLockConfigurationResult struct {
Bucket string `pulumi:"bucket"`
ExpectedBucketOwner *string `pulumi:"expectedBucketOwner"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
// Indicates whether this bucket has an Object Lock configuration enabled.
ObjectLockEnabled string `pulumi:"objectLockEnabled"`
Region string `pulumi:"region"`
@@ -123,11 +121,6 @@ func (o LookupBucketObjectLockConfigurationResultOutput) ExpectedBucketOwner() p
return o.ApplyT(func(v LookupBucketObjectLockConfigurationResult) *string { return v.ExpectedBucketOwner }).(pulumi.StringPtrOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o LookupBucketObjectLockConfigurationResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v LookupBucketObjectLockConfigurationResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
// Indicates whether this bucket has an Object Lock configuration enabled.
func (o LookupBucketObjectLockConfigurationResultOutput) ObjectLockEnabled() pulumi.StringOutput {
return o.ApplyT(func(v LookupBucketObjectLockConfigurationResult) string { return v.ObjectLockEnabled }).(pulumi.StringOutput)
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketReplicationConfiguration.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketReplicationConfiguration.go
index b0941ed62..71f495895 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketReplicationConfiguration.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBucketReplicationConfiguration.go
@@ -61,8 +61,6 @@ type GetBucketReplicationConfigurationArgs struct {
// A collection of values returned by getBucketReplicationConfiguration.
type GetBucketReplicationConfigurationResult struct {
Bucket string `pulumi:"bucket"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
Region string `pulumi:"region"`
// The ARN of the IAM role that Amazon S3 assumes when replicating objects.
Role string `pulumi:"role"`
@@ -110,11 +108,6 @@ func (o GetBucketReplicationConfigurationResultOutput) Bucket() pulumi.StringOut
return o.ApplyT(func(v GetBucketReplicationConfigurationResult) string { return v.Bucket }).(pulumi.StringOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetBucketReplicationConfigurationResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetBucketReplicationConfigurationResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetBucketReplicationConfigurationResultOutput) Region() pulumi.StringOutput {
return o.ApplyT(func(v GetBucketReplicationConfigurationResult) string { return v.Region }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBuckets.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBuckets.go
index 8fe2c6c93..8658fa72d 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBuckets.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getBuckets.go
@@ -93,12 +93,10 @@ type GetBucketsResult struct {
// Bucket region.
BucketRegion *string `pulumi:"bucketRegion"`
// List of bucket objects:
- Buckets []GetBucketsBucket `pulumi:"buckets"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- MaxBuckets *int `pulumi:"maxBuckets"`
- Prefix *string `pulumi:"prefix"`
- Region string `pulumi:"region"`
+ Buckets []GetBucketsBucket `pulumi:"buckets"`
+ MaxBuckets *int `pulumi:"maxBuckets"`
+ Prefix *string `pulumi:"prefix"`
+ Region string `pulumi:"region"`
}
func GetBucketsOutput(ctx *pulumi.Context, args GetBucketsOutputArgs, opts ...pulumi.InvokeOption) GetBucketsResultOutput {
@@ -151,11 +149,6 @@ func (o GetBucketsResultOutput) Buckets() GetBucketsBucketArrayOutput {
return o.ApplyT(func(v GetBucketsResult) []GetBucketsBucket { return v.Buckets }).(GetBucketsBucketArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetBucketsResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetBucketsResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetBucketsResultOutput) MaxBuckets() pulumi.IntPtrOutput {
return o.ApplyT(func(v GetBucketsResult) *int { return v.MaxBuckets }).(pulumi.IntPtrOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getFilesFileSystems.go b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getFilesFileSystems.go
index 5b9f5f8d1..66a68fee7 100644
--- a/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getFilesFileSystems.go
+++ b/vendor/github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3/getFilesFileSystems.go
@@ -58,9 +58,7 @@ type GetFilesFileSystemsArgs struct {
type GetFilesFileSystemsResult struct {
// List of file systems. See `fileSystems` below.
FileSystems []GetFilesFileSystemsFileSystem `pulumi:"fileSystems"`
- // The provider-assigned unique ID for this managed resource.
- Id string `pulumi:"id"`
- Region string `pulumi:"region"`
+ Region string `pulumi:"region"`
}
func GetFilesFileSystemsOutput(ctx *pulumi.Context, args GetFilesFileSystemsOutputArgs, opts ...pulumi.InvokeOption) GetFilesFileSystemsResultOutput {
@@ -104,11 +102,6 @@ func (o GetFilesFileSystemsResultOutput) FileSystems() GetFilesFileSystemsFileSy
return o.ApplyT(func(v GetFilesFileSystemsResult) []GetFilesFileSystemsFileSystem { return v.FileSystems }).(GetFilesFileSystemsFileSystemArrayOutput)
}
-// The provider-assigned unique ID for this managed resource.
-func (o GetFilesFileSystemsResultOutput) Id() pulumi.StringOutput {
- return o.ApplyT(func(v GetFilesFileSystemsResult) string { return v.Id }).(pulumi.StringOutput)
-}
-
func (o GetFilesFileSystemsResultOutput) Region() pulumi.StringOutput {
return o.ApplyT(func(v GetFilesFileSystemsResult) string { return v.Region }).(pulumi.StringOutput)
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/authorization/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/authorization/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/authorization/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/authorization/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/compute/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/compute/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/compute/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/compute/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/network/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/network/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/network/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/network/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/resources/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/resources/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/resources/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/resources/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/storage/v3/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-azure-native-sdk/storage/v3/pulumi-plugin.json
index a94227cae..75dac6bf5 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/storage/v3/pulumi-plugin.json
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/storage/v3/pulumi-plugin.json
@@ -1,5 +1,5 @@
{
"resource": true,
"name": "azure-native",
- "version": "3.24.0"
+ "version": "3.25.0"
}
diff --git a/vendor/github.com/pulumi/pulumi-azure-native-sdk/v3/utilities/pulumiUtilities.go b/vendor/github.com/pulumi/pulumi-azure-native-sdk/v3/utilities/pulumiUtilities.go
index 1d577dd44..1cc0d8b9f 100644
--- a/vendor/github.com/pulumi/pulumi-azure-native-sdk/v3/utilities/pulumiUtilities.go
+++ b/vendor/github.com/pulumi/pulumi-azure-native-sdk/v3/utilities/pulumiUtilities.go
@@ -165,7 +165,7 @@ func callPlainInner(
func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption {
defaults := []pulumi.ResourceOption{}
- version := semver.MustParse("3.24.0")
+ version := semver.MustParse("3.25.0")
if !version.Equals(semver.Version{}) {
defaults = append(defaults, pulumi.Version(version.String()))
}
@@ -176,7 +176,7 @@ func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOptio
func PkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption {
defaults := []pulumi.InvokeOption{}
- version := semver.MustParse("3.24.0")
+ version := semver.MustParse("3.25.0")
if !version.Equals(semver.Version{}) {
defaults = append(defaults, pulumi.Version(version.String()))
}
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/.version b/vendor/github.com/pulumi/pulumi/sdk/v3/.version
index 92af96bb4..fa7895b27 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/.version
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/.version
@@ -1 +1 @@
-3.255.0
+3.256.0
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/commands.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/commands.go
index f74c718d0..4932f237d 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/commands.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/commands.go
@@ -404,10 +404,6 @@ func (a *API) Import(
// * `pulumi new https://:@//`
// * `pulumi new @:/`
// * `PULUMI_GITSSH_PASSPHRASE= pulumi new ssh://@//`
-// To create a project using Pulumi AI, either select `ai` from the first selection, or provide any of the following:
-// * `pulumi new --ai ""`
-// * `pulumi new --language `
-// * `pulumi new --ai "" --language `
// Any missing but required information will be prompted for.
func (a *API) New(
ctx context.Context,
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/optnew/options.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/optnew/options.go
index c58f10466..dc26e236a 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/optnew/options.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/automation/optnew/options.go
@@ -30,7 +30,7 @@ type Options struct {
Stderr io.Writer
// Stdin, when non-nil, is connected to the child process' stdin.
Stdin io.Reader
- // Prompt to use for Pulumi AI
+ // Retired: use 'pulumi neo -p "prompt"' instead.
AI string
// Colorize output. Choices are: always, never, raw, auto
Color string
@@ -50,7 +50,7 @@ type Options struct {
FullyQualifyStackNames bool
// Generate the project only; do not create a stack, save config, or install dependencies
GenerateOnly bool
- // Language to use for Pulumi AI (must be one of TypeScript, JavaScript, Python, Go, C#, Java, or YAML)
+ // Retired: use 'pulumi neo -p "prompt"' instead.
Language string
// List locally installed templates and exit
ListTemplates bool
@@ -76,7 +76,7 @@ type Options struct {
SecretsProvider string
// The stack name; either an existing stack or stack to create; if not specified, a prompt will request it
Stack string
- // Run in template mode, which will skip prompting for AI or Template functionality
+ // Deprecated: template mode is now the only mode; this flag is a no-op
TemplateMode bool
// Emit tracing to the specified endpoint. Use the `file:` scheme to write tracing data to a local file
Tracing string
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/stack.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/stack.go
index 091c6dd7e..9fbf95e59 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/stack.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/auto/stack.go
@@ -106,6 +106,7 @@ import (
"path/filepath"
"regexp"
"runtime"
+ "slices"
"strconv"
"strings"
"sync"
@@ -613,9 +614,12 @@ func (s *Stack) ImportResources(ctx context.Context, opts ...optimport.Option) (
return res, fmt.Errorf("failed to import resources: %w", err)
}
- generatedCode, err := os.ReadFile(generatedCodePath)
- if err != nil {
- return res, fmt.Errorf("failed to read generated code: %w", err)
+ var generatedCode []byte
+ if importOpts.GenerateCode == nil || *importOpts.GenerateCode {
+ generatedCode, err = os.ReadFile(generatedCodePath)
+ if err != nil {
+ return res, fmt.Errorf("failed to read generated code: %w", err)
+ }
}
var summary UpdateSummary
@@ -1577,8 +1581,15 @@ func (s *Stack) runPulumiCmdSync(
if err != nil {
return "", "", -1, fmt.Errorf("failed to exec command, error getting additional args: %w", err)
}
+ // Everything after a "--" separator is positional and must stay last; insert our flags before it.
+ var positional []string
+ if i := slices.Index(args, "--"); i >= 0 {
+ positional = args[i:]
+ args = args[:i:i]
+ }
args = append(args, additionalArgs...)
args = append(args, "--stack", s.Name())
+ args = append(args, positional...)
stdout, stderr, errCode, err := s.workspace.PulumiCommand().Run(
ctx,
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/env/env.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/env/env.go
index a9f1f2c1a..58b424cc4 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/env/env.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/env/env.go
@@ -195,11 +195,6 @@ var (
"Number of parallel operations when fetching stacks and resources from the DIY backend.")
)
-// Environment variables which affect Pulumi AI integrations
-var (
- AIServiceEndpoint = env.String("AI_SERVICE_ENDPOINT", "Endpoint for Pulumi AI service")
-)
-
var DisableValidation = env.Bool(
"DISABLE_VALIDATION",
`Disables format validation of system inputs.
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/cloud_credentials.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/cloud_credentials.go
deleted file mode 100644
index e4dca66e1..000000000
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/cloud_credentials.go
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2026, Pulumi Corporation.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package plugin
-
-import (
- "strings"
-
- "github.com/pulumi/pulumi/sdk/v3/go/common/env"
- "github.com/pulumi/pulumi/sdk/v3/go/common/workspace"
-)
-
-// pulumiCloudCredentialEnv resolves the Pulumi Cloud API address and access token to expose to
-// plugins launched with this context, so trusted providers can reach the cloud on the user's
-// behalf. It returns nil for non-cloud logins and when logged out, so plugins only ever receive
-// credentials they can actually use.
-func pulumiCloudCredentialEnv(project *workspace.Project) map[string]string {
- url := currentCloudURL(project)
- if !strings.HasPrefix(url, "https://") && !strings.HasPrefix(url, "http://") {
- return nil
- }
-
- token := env.AccessToken.Value()
- if token == "" {
- if account, _, err := workspace.GetAccountWithAgentFallback(url); err == nil {
- token = account.AccessToken
- }
- }
- if token == "" {
- return nil
- }
-
- return map[string]string{
- env.APIURL.Var().Name(): url,
- env.AccessToken.Var().Name(): token,
- }
-}
-
-// currentCloudURL mirrors the CLI's backend selection: PULUMI_BACKEND_URL wins, then the project's
-// backend, then the active stored login, falling back to shared agent credentials.
-func currentCloudURL(project *workspace.Project) string {
- if url := env.BackendURL.Value(); url != "" {
- return url
- }
- if project != nil && project.Backend != nil && project.Backend.URL != "" {
- return project.Backend.URL
- }
- if creds, err := workspace.GetStoredCredentials(); err == nil && creds.Current != "" {
- return creds.Current
- }
- if workspace.AgentCredentialsFallbackEnabled() {
- if creds, err := workspace.GetAgentStoredCredentials(); err == nil {
- return creds.Current
- }
- }
- return ""
-}
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/context.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/context.go
index b7185a115..f9fa31f88 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/context.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin/context.go
@@ -224,11 +224,9 @@ func NewContextWithRoot(ctx context.Context, d, statusD diag.Sink, host Host,
}
var projectName tokens.PackageName
- var project *workspace.Project
projPath, err := workspace.DetectProjectPath()
if err == nil && projPath != "" {
if p, loadErr := workspace.LoadProject(projPath); loadErr == nil {
- project = p
projectName = p.Name
}
}
@@ -249,7 +247,9 @@ func NewContextWithRoot(ctx context.Context, d, statusD diag.Sink, host Host,
disableProviderPreview: disableProviderPreview,
config: config,
projectName: projectName,
- CloudCredentialEnv: pulumiCloudCredentialEnv(project),
+ // ripped out of sdk/go/common support, this is used for plugins running via the CLI against a real backend, we
+ // don't expect other tools still using Context to need this.
+ CloudCredentialEnv: nil,
}
projectPlugins, err := projectPluginsFromProject(pctx, plugins, packages)
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/httputil/http.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/httputil/http.go
index c6ceb0b9d..d6c9408fc 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/httputil/http.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/httputil/http.go
@@ -17,6 +17,7 @@ package httputil
import (
"context"
"net/http"
+ "strconv"
"strings"
"time"
@@ -24,6 +25,29 @@ import (
"github.com/pulumi/pulumi/sdk/v3/go/common/util/retry"
)
+const maxRetryAfterDelay = 30 * time.Second
+
+// retryAfterDelay returns the capped delay from a Retry-After header (RFC 9110
+// delay-seconds or HTTP-date), or 0 if absent or unparseable.
+func retryAfterDelay(res *http.Response, now time.Time) time.Duration {
+ header := res.Header.Get("Retry-After")
+ if header == "" {
+ return 0
+ }
+ var delay time.Duration
+ if seconds, err := strconv.Atoi(header); err == nil {
+ delay = time.Duration(seconds) * time.Second
+ } else if date, err := http.ParseTime(header); err == nil {
+ delay = date.Sub(now)
+ } else {
+ return 0
+ }
+ if delay <= 0 {
+ return 0
+ }
+ return min(delay, maxRetryAfterDelay)
+}
+
// RetryOpts defines options to configure the retry behavior.
// Leave nil for defaults.
type RetryOpts struct {
@@ -89,6 +113,22 @@ func doWithRetry(req *http.Request, client *http.Client, opts RetryOpts) (*http.
}
return true, res, resErr
}
+
+ // 429s are retried like 5xxs, but honor the server's Retry-After (capped)
+ // before the regular backoff.
+ if resErr == nil && res.StatusCode == http.StatusTooManyRequests && try < maxRetryCount-1 {
+ delay := retryAfterDelay(res, time.Now())
+ contract.IgnoreClose(res.Body)
+ if delay > 0 {
+ select {
+ case <-req.Context().Done():
+ return true, nil, req.Context().Err()
+ case <-time.After(delay):
+ }
+ }
+ return false, nil, nil
+ }
+
if resErr == nil && !inRange(res.StatusCode, 500, 599) {
return true, res, nil
}
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/logging/log.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/logging/log.go
index d3ab98fda..545b84f68 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/logging/log.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/util/logging/log.go
@@ -43,10 +43,6 @@ import (
"github.com/pulumi/pulumi/sdk/v3/go/common/slice"
)
-type Filter interface {
- Filter(s string) string
-}
-
var (
LogToStderr = false // true if logging is being redirected to stderr.
Verbose = 0 // >0 if verbose logging is enabled at a particular level.
@@ -54,8 +50,11 @@ var (
)
var (
- rwLock sync.RWMutex
- filters []Filter
+ rwLock sync.RWMutex
+
+ secretsSeen map[string]struct{}
+ secretsPairs []string
+ secretsReplacer *strings.Replacer
)
var (
@@ -446,27 +445,7 @@ func (f formattingHandler) WithGroup(name string) slog.Handler {
return formattingHandler{inner: f.inner.WithGroup(name)}
}
-type nopFilter struct{}
-
-func (f *nopFilter) Filter(s string) string {
- return s
-}
-
-type replacerFilter struct {
- replacer *strings.Replacer
-}
-
-func (f *replacerFilter) Filter(s string) string {
- return f.replacer.Replace(s)
-}
-
-func AddGlobalFilter(filter Filter) {
- rwLock.Lock()
- filters = append(filters, filter)
- rwLock.Unlock()
-}
-
-func CreateFilter(secrets []string, replacement string) Filter {
+func replacements(secrets []string, replacement string) []string {
items := slice.Prealloc[string](len(secrets))
for _, secret := range secrets {
// For short secrets, don't actually add them to the filter, this is a trade-off we make to prevent
@@ -488,23 +467,41 @@ func CreateFilter(secrets []string, replacement string) Filter {
items = append(items, escaped, replacement)
}
}
- if len(items) > 0 {
- return &replacerFilter{replacer: strings.NewReplacer(items...)}
- }
+ return items
+}
- return &nopFilter{}
+// AddGlobalSecretFilter registers secrets to be replaced by FilterString. Secrets registered
+// here are deduplicated and folded into a single replacer, so FilterString makes one pass over
+// its input no matter how many operations register their secrets.
+func AddGlobalSecretFilter(secrets []string, replacement string) {
+ rwLock.Lock()
+ defer rwLock.Unlock()
+
+ changed := false
+ for _, secret := range secrets {
+ if _, seen := secretsSeen[secret]; seen {
+ continue
+ }
+ if secretsSeen == nil {
+ secretsSeen = map[string]struct{}{}
+ }
+ secretsSeen[secret] = struct{}{}
+ secretsPairs = append(secretsPairs, replacements([]string{secret}, replacement)...)
+ changed = true
+ }
+ if changed && len(secretsPairs) > 0 {
+ secretsReplacer = strings.NewReplacer(secretsPairs...)
+ }
}
func FilterString(msg string) string {
- var localFilters []Filter
rwLock.RLock()
- localFilters = filters
+ secretsFilter := secretsReplacer
rwLock.RUnlock()
- for _, filter := range localFilters {
- msg = filter.Filter(msg)
+ if secretsFilter != nil {
+ msg = secretsFilter.Replace(msg)
}
-
return msg
}
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/workspace/creds.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/workspace/creds.go
index 6aead0684..3d833e4be 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/workspace/creds.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/common/workspace/creds.go
@@ -392,7 +392,7 @@ func readCredentialsFile(credsFile string) (Credentials, error) {
}
}
- logging.AddGlobalFilter(logging.CreateFilter(secrets, "[credential]"))
+ logging.AddGlobalSecretFilter(secrets, "[credential]")
return creds, nil
}
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/context.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/context.go
index 9fb573f1d..a2d9aaca3 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/context.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/context.go
@@ -81,6 +81,7 @@ type contextState struct {
supportsParameterization bool // true if package references and parameterized providers are supported by pulumi
supportsResourceHooks bool // true if resource hooks are supported by pulumi
supportsErrorHooks bool // true if error hooks are supported by pulumi
+ supportsInvokeDependsOn bool // true if the monitor gates invokes on their declared dependencies.
rpcs int // the number of outstanding RPC requests.
rpcsDone *sync.Cond // an event signaling completion of RPCs.
rpcsLock sync.Mutex // a lock protecting the RPC count and event.
@@ -187,6 +188,7 @@ func NewContext(ctx context.Context, info RunInfo) (*Context, error) {
supportsParameterization: has(pulumirpc.ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_PARAMETERIZATION),
supportsResourceHooks: has(pulumirpc.ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_RESOURCE_HOOKS),
supportsErrorHooks: has(pulumirpc.ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_ERROR_HOOKS),
+ supportsInvokeDependsOn: has(pulumirpc.ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_INVOKE_DEPENDS_ON),
registeredOutputs: make(map[URN]bool),
}
contextState.rpcsDone = sync.NewCond(&contextState.rpcsLock)
@@ -722,62 +724,144 @@ func (ctx *Context) Invoke(tok string, args any, result any, opts ...InvokeOptio
return ctx.InvokePackage(tok, args, result, "" /* packageRef */, opts...)
}
-// InvokePackage will invoke a provider's function, identified by its token tok. This function call is synchronous.
+// invokePackageRaw synchronously invokes the provider function tok with args marshaled per
+// marshalOpts, returning the response properties, the invoke's direct dependencies (the
+// resources its arguments depend on plus the DependsOn options), whether the result is known,
+// and whether an argument was secret. Secret arguments are sent to the provider as raw values.
//
-// args and result must be pointers to struct values fields and appropriately tagged and typed for use with Pulumi.
+// If checkDependencies is set, the invoke is skipped with known=false while any argument
+// is unknown or any dependency is pending creation. Plain invokes pass false: their
+// arguments cannot contain outputs, and their resource-reference arguments are not
+// existence-gated.
func (ctx *Context) invokePackageRaw(
- tok string, args any, packageRef string, options invokeOptions,
-) (resource.PropertyMap, error) {
+ tok string, args any, marshalOpts *marshalOptions, checkDependencies bool, packageRef string,
+ options invokeOptions,
+) (outProps resource.PropertyMap, deps []Resource, known, secret bool, err error) {
if tok == "" {
- return nil, errors.New("invoke token must not be empty")
+ return nil, nil, false, false, errors.New("invoke token must not be empty")
+ }
+
+ if args == nil {
+ args = struct{}{}
+ }
+ resolvedArgs, deps, err := marshalInputOptions(args, anyType, marshalOpts)
+ if err != nil {
+ return nil, nil, false, false, fmt.Errorf("marshaling arguments: %w", err)
+ }
+ secret = resolvedArgs.ContainsSecrets()
+
+ var invokeDependsOn []string
+ if checkDependencies {
+ // The expanded set of dependencies, including children of components.
+ depSet := map[URN]Resource{}
+ if err := resourceDependencySet(deps).addDeps(ctx.ctx, depSet, nil); err != nil {
+ return nil, nil, false, false, err
+ }
+ for _, d := range options.DependsOn {
+ if err := d.addDeps(ctx.ctx, depSet, nil); err != nil {
+ return nil, nil, false, false, err
+ }
+ switch d := d.(type) {
+ case resourceDependencySet:
+ deps = append(deps, d...)
+ case *resourceArrayInputDependencySet:
+ out := d.input.ToResourceArrayOutput()
+ value, k, _, _, err := internal.AwaitOutput(ctx.Context(), out)
+ if err != nil {
+ return nil, nil, false, false, err
+ }
+ if !k {
+ // We don't know what the dependencies are, so the result is unknown.
+ return nil, deps, false, secret, nil
+ }
+ resources, ok := value.([]Resource)
+ if !ok {
+ return nil, nil, false, false, fmt.Errorf(
+ "expected DependsOnInputs to resolve to []Resource, got %T", value)
+ }
+ deps = append(deps, resources...)
+ default:
+ // Unreachable.
+ // We control all implementations of dependencySet.
+ contract.Failf("Unknown dependencySet %T", d)
+ }
+ }
+
+ if resolvedArgs.ContainsUnknowns() {
+ return nil, deps, false, secret, nil
+ }
+
+ if ctx.state.supportsInvokeDependsOn {
+ invokeDependsOn = make([]string, 0, len(depSet))
+ for urn := range depSet {
+ invokeDependsOn = append(invokeDependsOn, string(urn))
+ }
+ } else {
+ // Older engines need the language to manage the await.
+ //
+ // DependsOn for resources is an ordering constraint for register
+ // resource calls. If a resource R1 depends on a resource R2, the
+ // register resource call for R2 will happen after R1. This is ensured
+ // by awaiting the URN for each resource dependency before calling
+ // register resource.
+ //
+ // For invokes, this causes a problem when running under preview. During
+ // preview, register resource immediately returns with the URN, however
+ // this does not tell us if the resource "exists".
+ //
+ // Instead of waiting for the dependency's URN, we wait for the ID. This
+ // tells us that wether a physical resource exists (if the state does
+ // not require a refresh), and we can avoid calling the invoke when it
+ // is unknown.
+ for _, d := range depSet {
+ if r, ok := d.(CustomResource); ok {
+ _, k, _, _, err := internal.AwaitOutput(ctx.Context(), r.ID())
+ if err != nil {
+ contract.Failf("Awaiting ID: %s", err)
+ }
+ if !k {
+ return nil, deps, false, secret, nil
+ }
+ }
+ }
+ }
+ }
+
+ resolvedArgsMap := resource.PropertyMap{}
+ if resolvedArgs.IsObject() {
+ resolvedArgsMap = resolvedArgs.ObjectValue()
}
+
// Note that we're about to make an outstanding RPC request, so that we can rendezvous during shutdown.
- var err error
if err = ctx.beginRPC(); err != nil {
- return nil, err
+ return nil, nil, false, false, err
}
defer ctx.endRPC(err)
var providerRef string
providers, err := ctx.mergeProviders(tok, options.Parent, options.Provider, nil)
if err != nil {
- return nil, err
+ return nil, nil, false, false, err
}
if provider := providers[getPackage(tok)]; provider != nil {
pr, err := ctx.resolveProviderReference(provider)
if err != nil {
- return nil, err
+ return nil, nil, false, false, err
}
providerRef = pr
}
- // Serialize arguments. Outputs will not be awaited: instead, an error will be returned if any Outputs are present.
- if args == nil {
- args = struct{}{}
- }
- resolvedArgs, _, err := marshalInputOptions(args, anyType, &marshalOptions{
- ErrorOnOutput: true,
- })
- if err != nil {
- return nil, fmt.Errorf("marshaling arguments: %w", err)
- }
-
- resolvedArgsMap := resource.PropertyMap{}
- if resolvedArgs.IsObject() {
- resolvedArgsMap = resolvedArgs.ObjectValue()
- }
-
rpcArgs, err := plugin.MarshalProperties(
resolvedArgsMap,
plugin.MarshalOptions{
KeepUnknowns: true,
- KeepSecrets: true,
+ KeepSecrets: false,
KeepResources: ctx.state.keepResources,
KeepByteString: ctx.state.keepByteString,
},
)
if err != nil {
- return nil, fmt.Errorf("marshaling arguments: %w", err)
+ return nil, nil, false, false, fmt.Errorf("marshaling arguments: %w", err)
}
// Now, invoke the RPC to the provider synchronously.
@@ -791,10 +875,11 @@ func (ctx *Context) invokePackageRaw(
AcceptResources: !disableResourceReferences,
AcceptsByteString: true,
PackageRef: packageRef,
+ DependsOn: invokeDependsOn,
})
if err != nil {
logging.V(9).Infof("Invoke(%s, ...): error: %v", tok, err)
- return nil, err
+ return nil, nil, false, false, err
}
// If there were any failures from the provider, return them.
@@ -805,11 +890,16 @@ func (ctx *Context) invokePackageRaw(
ferr = multierror.Append(ferr,
fmt.Errorf("%s invoke failed: %s (%s)", tok, failure.Reason, failure.Property))
}
- return nil, ferr
+ return nil, nil, false, false, ferr
+ }
+
+ // The engine declined to service the invoke because dependencies are pending creation.
+ if resp.Unknown {
+ return nil, deps, false, secret, nil
}
// Otherwise, simply unmarshal the output properties and return the result.
- r, err := plugin.UnmarshalProperties(
+ outProps, err = plugin.UnmarshalProperties(
resp.Return,
plugin.MarshalOptions{
KeepUnknowns: true,
@@ -817,9 +907,9 @@ func (ctx *Context) invokePackageRaw(
KeepResources: true,
})
if err != nil {
- return nil, err
+ return nil, nil, false, false, err
}
- return r, nil
+ return outProps, deps, true, secret, nil
}
func validInvokeResult(resultV reflect.Value) bool {
@@ -841,12 +931,10 @@ func (ctx *Context) InvokePackage(
}
invokeOpts := mergeInvokeOptions(opts...)
- if len(invokeOpts.DependsOn) > 0 {
- // Ignore the DependsOn option for direct invokes.
- invokeOpts.DependsOn = nil
- }
+ invokeOpts.DependsOn = nil // Ignore the DependsOn option for direct invokes.
- outProps, err := ctx.invokePackageRaw(tok, args, packageRef, *invokeOpts)
+ outProps, _, _, _, err := ctx.invokePackageRaw(tok, args, &marshalOptions{ErrorOnOutput: true},
+ false /* checkDependencies */, packageRef, *invokeOpts)
if err != nil {
return err
}
@@ -861,7 +949,7 @@ func (ctx *Context) InvokePackage(
}
// InvokePackageRaw is similar to InvokePackage except that it doesn't error out if the result has secrets.
-// Insread, it returns a boolean indicating if the result has secrets.
+// Instead, it returns a boolean indicating if the result has secrets.
func (ctx *Context) InvokePackageRaw(
tok string, args any, result any, packageRef string, opts ...InvokeOption,
) (isSecret bool, err error) {
@@ -871,7 +959,8 @@ func (ctx *Context) InvokePackageRaw(
}
options := mergeInvokeOptions(opts...)
- outProps, err := ctx.invokePackageRaw(tok, args, packageRef, *options)
+ outProps, _, _, _, err := ctx.invokePackageRaw(tok, args, &marshalOptions{ErrorOnOutput: true},
+ false /* checkDependencies */, packageRef, *options)
if err != nil {
return false, err
}
@@ -887,6 +976,10 @@ func (ctx *Context) InvokePackageRaw(
type InvokeOutputOptions struct {
// The package reference for parameterized providers.
PackageRef string
+ // PackageRefF lazily resolves the package reference for parameterized providers.
+ //
+ // When set, it takes precedence over PackageRef.
+ PackageRefF func(*Context) (string, error)
// The options provided by the user for the invoke call, such as `Provider`,
// `Version, `DependsOn`, etc.
InvokeOptions []InvokeOption
@@ -895,83 +988,47 @@ type InvokeOutputOptions struct {
// InvokeOutput will invoke a provider's function, identified by its token tok. This function is
// used by generated SDK code for Output form invokes.
// `output` is used to determine the output type to return.
+//
+// Unlike Invoke, args may contain Inputs/Outputs. The invoke's resource dependencies are inferred
+// from the arguments (in addition to any explicit DependsOn options), and if any argument is
+// unknown the invoke is not performed and the result is unknown.
func (ctx *Context) InvokeOutput(
tok string, args any, output Output, options InvokeOutputOptions,
) Output {
output = ctx.newOutput(reflect.TypeOf(output))
go func() {
- // Collect dependencies from the DependsOn/DependsOnInput options.
- invokeOpts := mergeInvokeOptions(options.InvokeOptions...)
- deps := []Resource{} // The direct dependencies of the invoke.
- depSet := map[URN]Resource{} // The expanded set of dependencies, including children.
- for _, d := range invokeOpts.DependsOn {
- if err := d.addDeps(ctx.ctx, depSet, nil); err != nil {
+ packageRef := options.PackageRef
+ if options.PackageRefF != nil {
+ ref, err := options.PackageRefF(ctx)
+ if err != nil {
+ internal.RejectOutput(output, err)
return
}
- switch d := d.(type) {
- case resourceDependencySet:
- deps = append(deps, d...)
- case *resourceArrayInputDependencySet:
- out := d.input.ToResourceArrayOutput()
- value, known, _, _, err := internal.AwaitOutput(ctx.Context(), out)
- if err != nil || !known {
- return
- }
- resources, ok := value.([]Resource)
- if !ok {
- return
- }
- deps = append(deps, resources...)
- default:
- // Unreachable.
- // We control all implementations of dependencySet.
- contract.Failf("Unknown dependencySet %T", d)
- }
+ packageRef = ref
}
- dest := reflect.New(output.ElementType()).Elem()
-
- // DependsOn for resources is an ordering constraint for register
- // resource calls. If a resource R1 depends on a resource R2, the
- // register resource call for R2 will happen after R1. This is ensured
- // by awaiting the URN for each resource dependency before calling
- // register resource.
- //
- // For invokes, this causes a problem when running under preview. During
- // preview, register resource immediately returns with the URN, however
- // this does not tell us if the resource "exists".
- //
- // Instead of waiting for the dependency's URN, we wait for the ID. This
- // tells us that wether a physical resource exists (if the state does
- // not require a refresh), and we can avoid calling the invoke when it
- // is unknown.
- for _, d := range depSet {
- if r, ok := d.(CustomResource); ok {
- _, known, _, _, err := internal.AwaitOutput(ctx.Context(), r.ID())
- if err != nil {
- contract.Failf("Awaiting ID: %s", err)
- }
- if !known {
- internal.ResolveOutput(output, dest.Interface(), known, false, resourcesToInternal(deps))
- return
- }
- }
- }
-
- outProps, err := ctx.invokePackageRaw(tok, args, options.PackageRef, *invokeOpts)
+ invokeOpts := mergeInvokeOptions(options.InvokeOptions...)
+ outProps, deps, known, secret, err := ctx.invokePackageRaw(tok, args, nil, /* marshalOpts */
+ true /* checkDependencies */, packageRef, *invokeOpts)
if err != nil {
internal.RejectOutput(output, err)
return
}
- known := !outProps.ContainsUnknowns()
- secret, err := unmarshalOutput(ctx, resource.NewProperty(outProps), dest)
+ dest := reflect.New(output.ElementType()).Elem()
+ if !known {
+ internal.ResolveOutput(output, dest.Interface(), false, secret, resourcesToInternal(deps))
+ return
+ }
+
+ known = !outProps.ContainsUnknowns()
+ respSecret, err := unmarshalOutput(ctx, resource.NewProperty(outProps), dest)
if err != nil {
internal.RejectOutput(output, err)
return
}
- internal.ResolveOutput(output, dest.Interface(), known, secret, resourcesToInternal(deps))
+ internal.ResolveOutput(output, dest.Interface(), known, secret || respSecret, resourcesToInternal(deps))
}()
return output
@@ -1903,6 +1960,9 @@ func (ctx *Context) registerResource(
if err == nil && resp.Result != pulumirpc.Result_SUCCESS {
err = fmt.Errorf("resource %s [%s] failed to register", name, t)
}
+ if custom && resp.Result == pulumirpc.Result_SUCCESS && resp.Unknown {
+ keepUnknowns = true
+ }
}
}()
@@ -2341,7 +2401,8 @@ func (state *resourceState) resolve(ctx *Context, err error, inputs *resourceInp
internal.ResolveOutput(state.rawOutputs, outprops, true, false, resourcesToInternal(nil))
for k, output := range state.outputs {
- // If this is an unknown or missing value during a dry run, do nothing.
+ // If this is an unknown or missing value during a dry run or for a skipped
+ // create, do nothing.
v, ok := outprops[resource.PropertyKey(k)]
if !ok && !keepUnknowns {
v = inprops[resource.PropertyKey(k)]
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/mocks.go b/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/mocks.go
index 8b9d45875..a707fe61f 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/mocks.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/go/pulumi/mocks.go
@@ -110,6 +110,8 @@ type MockResourceArgs struct {
}
type mockMonitor struct {
+ pulumirpc.UnimplementedResourceMonitorServer
+
project string
stack string
mocks MockResourceMonitor
@@ -143,6 +145,8 @@ func (m *mockMonitor) SupportsFeature(ctx context.Context, in *pulumirpc.Support
func (m *mockMonitor) GetDeploymentInfo(ctx context.Context, in *emptypb.Empty,
opts ...grpc.CallOption,
) (*pulumirpc.DeploymentInfo, error) {
+ // INVOKE_DEPENDS_ON is left out because the mock monitor implements no invoke
+ // dependency gate; leaving it out keeps the client-side one.
features := []pulumirpc.ResourceMonitorFeature{
pulumirpc.ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_SECRETS,
pulumirpc.ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_RESOURCE_REFERENCES,
@@ -166,7 +170,7 @@ func (m *mockMonitor) GetDeploymentInfo(ctx context.Context, in *emptypb.Empty,
func (m *mockMonitor) Invoke(ctx context.Context, in *pulumirpc.ResourceInvokeRequest,
opts ...grpc.CallOption,
-) (*pulumirpc.InvokeResponse, error) {
+) (*pulumirpc.ResourceInvokeResponse, error) {
args, err := plugin.UnmarshalProperties(in.GetArgs(), plugin.MarshalOptions{
KeepSecrets: true,
KeepResources: true,
@@ -189,7 +193,7 @@ func (m *mockMonitor) Invoke(ctx context.Context, in *pulumirpc.ResourceInvokeRe
if err != nil {
return nil, err
}
- return &pulumirpc.InvokeResponse{
+ return &pulumirpc.ResourceInvokeResponse{
Return: result,
}, nil
}
@@ -210,7 +214,7 @@ func (m *mockMonitor) Invoke(ctx context.Context, in *pulumirpc.ResourceInvokeRe
return nil, err
}
- return &pulumirpc.InvokeResponse{
+ return &pulumirpc.ResourceInvokeResponse{
Return: result,
}, nil
}
@@ -382,25 +386,25 @@ func (m *mockMonitor) RegisterResourceOutputs(ctx context.Context, in *pulumirpc
func (m *mockMonitor) RegisterStackTransform(ctx context.Context, in *pulumirpc.Callback,
opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
- panic("not implemented")
+ return &emptypb.Empty{}, nil
}
func (m *mockMonitor) RegisterStackInvokeTransform(ctx context.Context, in *pulumirpc.Callback,
opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
- panic("not implemented")
+ return &emptypb.Empty{}, nil
}
func (m *mockMonitor) RegisterResourceHook(ctx context.Context, in *pulumirpc.RegisterResourceHookRequest,
opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
- panic("not implemented")
+ return &emptypb.Empty{}, nil
}
func (m *mockMonitor) RegisterErrorHook(ctx context.Context, in *pulumirpc.RegisterErrorHookRequest,
opts ...grpc.CallOption,
) (*emptypb.Empty, error) {
- panic("not implemented")
+ return &emptypb.Empty{}, nil
}
func (m *mockMonitor) RegisterPackage(ctx context.Context, in *pulumirpc.RegisterPackageRequest,
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/converter.pb.go b/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/converter.pb.go
index 709d11d23..a5dcfc7ae 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/converter.pb.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/converter.pb.go
@@ -45,9 +45,12 @@ type ConvertStateRequest struct {
// import from.
Args []string `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
// The target of a codegen.LoaderServer to use for loading schemas.
- LoaderTarget string `protobuf:"bytes,3,opt,name=loader_target,json=loaderTarget,proto3" json:"loader_target,omitempty"`
- unknownFields protoimpl.UnknownFields
- sizeCache protoimpl.SizeCache
+ LoaderTarget string `protobuf:"bytes,3,opt,name=loader_target,json=loaderTarget,proto3" json:"loader_target,omitempty"`
+ // The target of a [](pulumirpc.PackageResolver) service the converter can use to resolve package
+ // specifications to concrete package dependencies. May be empty on older engines.
+ ResolverTarget string `protobuf:"bytes,4,opt,name=resolver_target,json=resolverTarget,proto3" json:"resolver_target,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
}
func (x *ConvertStateRequest) Reset() {
@@ -101,6 +104,13 @@ func (x *ConvertStateRequest) GetLoaderTarget() string {
return ""
}
+func (x *ConvertStateRequest) GetResolverTarget() string {
+ if x != nil {
+ return x.ResolverTarget
+ }
+ return ""
+}
+
// A ResourceImport specifies a resource to import.
type ResourceImport struct {
state protoimpl.MessageState `protogen:"open.v1"`
@@ -846,11 +856,12 @@ var File_pulumi_converter_proto protoreflect.FileDescriptor
const file_pulumi_converter_proto_rawDesc = "" +
"\n" +
- "\x16pulumi/converter.proto\x12\tpulumirpc\x1a\x1cgoogle/protobuf/struct.proto\x1a\x18pulumi/codegen/hcl.proto\x1a\x1bpulumi/codegen/loader.proto\"s\n" +
+ "\x16pulumi/converter.proto\x12\tpulumirpc\x1a\x1cgoogle/protobuf/struct.proto\x1a\x18pulumi/codegen/hcl.proto\x1a\x1bpulumi/codegen/loader.proto\"\x9c\x01\n" +
"\x13ConvertStateRequest\x12#\n" +
"\rmapper_target\x18\x01 \x01(\tR\fmapperTarget\x12\x12\n" +
"\x04args\x18\x02 \x03(\tR\x04args\x12#\n" +
- "\rloader_target\x18\x03 \x01(\tR\floaderTarget\"\xb8\x04\n" +
+ "\rloader_target\x18\x03 \x01(\tR\floaderTarget\x12'\n" +
+ "\x0fresolver_target\x18\x04 \x01(\tR\x0eresolverTarget\"\xb8\x04\n" +
"\x0eResourceImport\x12\x12\n" +
"\x04type\x18\x01 \x01(\tR\x04type\x12\x12\n" +
"\x04name\x18\x02 \x01(\tR\x04name\x12\x0e\n" +
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource.pb.go b/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource.pb.go
index 176a7f375..cad0cac2b 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource.pb.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource.pb.go
@@ -60,6 +60,9 @@ const (
// The monitor accepts strings containing bytes that are not valid UTF-8, marshaled as objects carrying the raw
// string bytes signature and a base64 encoding of the string's bytes.
ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_BYTE_STRING ResourceMonitorFeature = 13
+ // The monitor accepts `dependsOn` on `ResourceInvokeRequest` and gates the invoke on the created-ness of the
+ // dependencies, returning `unknown` on `ResourceInvokeResponse` when they are pending.
+ ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_INVOKE_DEPENDS_ON ResourceMonitorFeature = 14
// The monitor resolves an invoke's provider from the `parent` field on `ResourceInvokeRequest`.
ResourceMonitorFeature_RESOURCE_MONITOR_FEATURE_INVOKE_PARENT ResourceMonitorFeature = 15
)
@@ -81,6 +84,7 @@ var (
11: "RESOURCE_MONITOR_FEATURE_ERROR_HOOKS",
12: "RESOURCE_MONITOR_FEATURE_SENDS_OPTIONS_TO_HOOKS",
13: "RESOURCE_MONITOR_FEATURE_BYTE_STRING",
+ 14: "RESOURCE_MONITOR_FEATURE_INVOKE_DEPENDS_ON",
15: "RESOURCE_MONITOR_FEATURE_INVOKE_PARENT",
}
ResourceMonitorFeature_value = map[string]int32{
@@ -98,6 +102,7 @@ var (
"RESOURCE_MONITOR_FEATURE_ERROR_HOOKS": 11,
"RESOURCE_MONITOR_FEATURE_SENDS_OPTIONS_TO_HOOKS": 12,
"RESOURCE_MONITOR_FEATURE_BYTE_STRING": 13,
+ "RESOURCE_MONITOR_FEATURE_INVOKE_DEPENDS_ON": 14,
"RESOURCE_MONITOR_FEATURE_INVOKE_PARENT": 15,
}
)
@@ -1008,6 +1013,7 @@ type RegisterResourceResponse struct {
Stables []string `protobuf:"bytes,5,rep,name=stables,proto3" json:"stables,omitempty"` // an optional list of guaranteed-stable properties.
PropertyDependencies map[string]*RegisterResourceResponse_PropertyDependencies `protobuf:"bytes,6,rep,name=propertyDependencies,proto3" json:"propertyDependencies,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` // a map from property keys to the dependencies of the property.
Result Result `protobuf:"varint,7,opt,name=result,proto3,enum=pulumirpc.Result" json:"result,omitempty"` // the reason, whether the resource registration was successful, failed, or skipped.
+ Unknown bool `protobuf:"varint,8,opt,name=unknown,proto3" json:"unknown,omitempty"` // true if the result of the registration is unknown, e.g. because the create was elided by a targeted update or a destroy run; result is still SUCCESS and SDKs should resolve outputs as unknown.
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -1091,6 +1097,13 @@ func (x *RegisterResourceResponse) GetResult() Result {
return Result_SUCCESS
}
+func (x *RegisterResourceResponse) GetUnknown() bool {
+ if x != nil {
+ return x.Unknown
+ }
+ return false
+}
+
// RegisterResourceOutputsRequest adds extra resource outputs created by the program after registration has occurred.
type RegisterResourceOutputsRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
@@ -1160,6 +1173,10 @@ type ResourceInvokeRequest struct {
// When true operations may return strings containing bytes that are not valid UTF-8, marshaled as objects
// carrying the byte string signature and a base64 encoding of the string's bytes.
AcceptsByteString bool `protobuf:"varint,12,opt,name=accepts_byte_string,json=acceptsByteString,proto3" json:"accepts_byte_string,omitempty"`
+ // The URNs of the resources this invoke depends on.
+ //
+ // The engine will advertise `INVOKE_DEPENDS_ON` when it reads this field.
+ DependsOn []string `protobuf:"bytes,13,rep,name=dependsOn,proto3" json:"dependsOn,omitempty"`
// An optional URN of the resource this invoke is parented to. When `provider` is empty, the invoke is served by
// the provider its parent's `providers` option names for the invoke's package, the same resolution applied to
// resource registrations. Only respected when the monitor advertises `INVOKE_PARENT`.
@@ -1282,6 +1299,13 @@ func (x *ResourceInvokeRequest) GetAcceptsByteString() bool {
return false
}
+func (x *ResourceInvokeRequest) GetDependsOn() []string {
+ if x != nil {
+ return x.DependsOn
+ }
+ return nil
+}
+
func (x *ResourceInvokeRequest) GetParent() string {
if x != nil {
return x.Parent
@@ -1289,6 +1313,68 @@ func (x *ResourceInvokeRequest) GetParent() string {
return ""
}
+type ResourceInvokeResponse struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ Return *structpb.Struct `protobuf:"bytes,1,opt,name=return,proto3" json:"return,omitempty"` // the returned values, if invoke was successful.
+ Failures []*CheckFailure `protobuf:"bytes,2,rep,name=failures,proto3" json:"failures,omitempty"` // the failures if any arguments didn't pass verification.
+ // True if the result must be treated as wholly unknown, which the monitor reports when it declines to service an
+ // invoke whose dependencies are pending creation.
+ Unknown bool `protobuf:"varint,3,opt,name=unknown,proto3" json:"unknown,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *ResourceInvokeResponse) Reset() {
+ *x = ResourceInvokeResponse{}
+ mi := &file_pulumi_resource_proto_msgTypes[9]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *ResourceInvokeResponse) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ResourceInvokeResponse) ProtoMessage() {}
+
+func (x *ResourceInvokeResponse) ProtoReflect() protoreflect.Message {
+ mi := &file_pulumi_resource_proto_msgTypes[9]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use ResourceInvokeResponse.ProtoReflect.Descriptor instead.
+func (*ResourceInvokeResponse) Descriptor() ([]byte, []int) {
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{9}
+}
+
+func (x *ResourceInvokeResponse) GetReturn() *structpb.Struct {
+ if x != nil {
+ return x.Return
+ }
+ return nil
+}
+
+func (x *ResourceInvokeResponse) GetFailures() []*CheckFailure {
+ if x != nil {
+ return x.Failures
+ }
+ return nil
+}
+
+func (x *ResourceInvokeResponse) GetUnknown() bool {
+ if x != nil {
+ return x.Unknown
+ }
+ return false
+}
+
type ResourceCallRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
Tok string `protobuf:"bytes,1,opt,name=tok,proto3" json:"tok,omitempty"` // the function token to invoke.
@@ -1311,7 +1397,7 @@ type ResourceCallRequest struct {
func (x *ResourceCallRequest) Reset() {
*x = ResourceCallRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[9]
+ mi := &file_pulumi_resource_proto_msgTypes[10]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1323,7 +1409,7 @@ func (x *ResourceCallRequest) String() string {
func (*ResourceCallRequest) ProtoMessage() {}
func (x *ResourceCallRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[9]
+ mi := &file_pulumi_resource_proto_msgTypes[10]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1336,7 +1422,7 @@ func (x *ResourceCallRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use ResourceCallRequest.ProtoReflect.Descriptor instead.
func (*ResourceCallRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{9}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{10}
}
func (x *ResourceCallRequest) GetTok() string {
@@ -1452,7 +1538,7 @@ type TransformResourceOptions struct {
func (x *TransformResourceOptions) Reset() {
*x = TransformResourceOptions{}
- mi := &file_pulumi_resource_proto_msgTypes[10]
+ mi := &file_pulumi_resource_proto_msgTypes[11]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1464,7 +1550,7 @@ func (x *TransformResourceOptions) String() string {
func (*TransformResourceOptions) ProtoMessage() {}
func (x *TransformResourceOptions) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[10]
+ mi := &file_pulumi_resource_proto_msgTypes[11]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1477,7 +1563,7 @@ func (x *TransformResourceOptions) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransformResourceOptions.ProtoReflect.Descriptor instead.
func (*TransformResourceOptions) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{10}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{11}
}
func (x *TransformResourceOptions) GetDependsOn() []string {
@@ -1651,7 +1737,7 @@ type ResourceOptions struct {
func (x *ResourceOptions) Reset() {
*x = ResourceOptions{}
- mi := &file_pulumi_resource_proto_msgTypes[11]
+ mi := &file_pulumi_resource_proto_msgTypes[12]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1663,7 +1749,7 @@ func (x *ResourceOptions) String() string {
func (*ResourceOptions) ProtoMessage() {}
func (x *ResourceOptions) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[11]
+ mi := &file_pulumi_resource_proto_msgTypes[12]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1676,7 +1762,7 @@ func (x *ResourceOptions) ProtoReflect() protoreflect.Message {
// Deprecated: Use ResourceOptions.ProtoReflect.Descriptor instead.
func (*ResourceOptions) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{11}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{12}
}
func (x *ResourceOptions) GetDependsOn() []string {
@@ -1840,7 +1926,7 @@ type TransformRequest struct {
func (x *TransformRequest) Reset() {
*x = TransformRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[12]
+ mi := &file_pulumi_resource_proto_msgTypes[13]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1852,7 +1938,7 @@ func (x *TransformRequest) String() string {
func (*TransformRequest) ProtoMessage() {}
func (x *TransformRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[12]
+ mi := &file_pulumi_resource_proto_msgTypes[13]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1865,7 +1951,7 @@ func (x *TransformRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransformRequest.ProtoReflect.Descriptor instead.
func (*TransformRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{12}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{13}
}
func (x *TransformRequest) GetType() string {
@@ -1920,7 +2006,7 @@ type TransformResponse struct {
func (x *TransformResponse) Reset() {
*x = TransformResponse{}
- mi := &file_pulumi_resource_proto_msgTypes[13]
+ mi := &file_pulumi_resource_proto_msgTypes[14]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1932,7 +2018,7 @@ func (x *TransformResponse) String() string {
func (*TransformResponse) ProtoMessage() {}
func (x *TransformResponse) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[13]
+ mi := &file_pulumi_resource_proto_msgTypes[14]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1945,7 +2031,7 @@ func (x *TransformResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransformResponse.ProtoReflect.Descriptor instead.
func (*TransformResponse) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{13}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{14}
}
func (x *TransformResponse) GetProperties() *structpb.Struct {
@@ -1974,7 +2060,7 @@ type TransformInvokeRequest struct {
func (x *TransformInvokeRequest) Reset() {
*x = TransformInvokeRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[14]
+ mi := &file_pulumi_resource_proto_msgTypes[15]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -1986,7 +2072,7 @@ func (x *TransformInvokeRequest) String() string {
func (*TransformInvokeRequest) ProtoMessage() {}
func (x *TransformInvokeRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[14]
+ mi := &file_pulumi_resource_proto_msgTypes[15]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -1999,7 +2085,7 @@ func (x *TransformInvokeRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransformInvokeRequest.ProtoReflect.Descriptor instead.
func (*TransformInvokeRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{14}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{15}
}
func (x *TransformInvokeRequest) GetToken() string {
@@ -2034,7 +2120,7 @@ type TransformInvokeResponse struct {
func (x *TransformInvokeResponse) Reset() {
*x = TransformInvokeResponse{}
- mi := &file_pulumi_resource_proto_msgTypes[15]
+ mi := &file_pulumi_resource_proto_msgTypes[16]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2046,7 +2132,7 @@ func (x *TransformInvokeResponse) String() string {
func (*TransformInvokeResponse) ProtoMessage() {}
func (x *TransformInvokeResponse) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[15]
+ mi := &file_pulumi_resource_proto_msgTypes[16]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2059,7 +2145,7 @@ func (x *TransformInvokeResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransformInvokeResponse.ProtoReflect.Descriptor instead.
func (*TransformInvokeResponse) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{15}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{16}
}
func (x *TransformInvokeResponse) GetArgs() *structpb.Struct {
@@ -2089,7 +2175,7 @@ type TransformInvokeOptions struct {
func (x *TransformInvokeOptions) Reset() {
*x = TransformInvokeOptions{}
- mi := &file_pulumi_resource_proto_msgTypes[16]
+ mi := &file_pulumi_resource_proto_msgTypes[17]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2101,7 +2187,7 @@ func (x *TransformInvokeOptions) String() string {
func (*TransformInvokeOptions) ProtoMessage() {}
func (x *TransformInvokeOptions) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[16]
+ mi := &file_pulumi_resource_proto_msgTypes[17]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2114,7 +2200,7 @@ func (x *TransformInvokeOptions) ProtoReflect() protoreflect.Message {
// Deprecated: Use TransformInvokeOptions.ProtoReflect.Descriptor instead.
func (*TransformInvokeOptions) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{16}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{17}
}
func (x *TransformInvokeOptions) GetProvider() string {
@@ -2164,7 +2250,7 @@ type ResourceHookRequest struct {
func (x *ResourceHookRequest) Reset() {
*x = ResourceHookRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[17]
+ mi := &file_pulumi_resource_proto_msgTypes[18]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2176,7 +2262,7 @@ func (x *ResourceHookRequest) String() string {
func (*ResourceHookRequest) ProtoMessage() {}
func (x *ResourceHookRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[17]
+ mi := &file_pulumi_resource_proto_msgTypes[18]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2189,7 +2275,7 @@ func (x *ResourceHookRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use ResourceHookRequest.ProtoReflect.Descriptor instead.
func (*ResourceHookRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{17}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{18}
}
func (x *ResourceHookRequest) GetUrn() string {
@@ -2272,7 +2358,7 @@ type ResourceHookResponse struct {
func (x *ResourceHookResponse) Reset() {
*x = ResourceHookResponse{}
- mi := &file_pulumi_resource_proto_msgTypes[18]
+ mi := &file_pulumi_resource_proto_msgTypes[19]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2284,7 +2370,7 @@ func (x *ResourceHookResponse) String() string {
func (*ResourceHookResponse) ProtoMessage() {}
func (x *ResourceHookResponse) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[18]
+ mi := &file_pulumi_resource_proto_msgTypes[19]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2297,7 +2383,7 @@ func (x *ResourceHookResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use ResourceHookResponse.ProtoReflect.Descriptor instead.
func (*ResourceHookResponse) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{18}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{19}
}
func (x *ResourceHookResponse) GetError() string {
@@ -2327,7 +2413,7 @@ type ErrorHookRequest struct {
func (x *ErrorHookRequest) Reset() {
*x = ErrorHookRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[19]
+ mi := &file_pulumi_resource_proto_msgTypes[20]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2339,7 +2425,7 @@ func (x *ErrorHookRequest) String() string {
func (*ErrorHookRequest) ProtoMessage() {}
func (x *ErrorHookRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[19]
+ mi := &file_pulumi_resource_proto_msgTypes[20]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2352,7 +2438,7 @@ func (x *ErrorHookRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use ErrorHookRequest.ProtoReflect.Descriptor instead.
func (*ErrorHookRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{19}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{20}
}
func (x *ErrorHookRequest) GetUrn() string {
@@ -2443,7 +2529,7 @@ type ErrorHookResponse struct {
func (x *ErrorHookResponse) Reset() {
*x = ErrorHookResponse{}
- mi := &file_pulumi_resource_proto_msgTypes[20]
+ mi := &file_pulumi_resource_proto_msgTypes[21]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2455,7 +2541,7 @@ func (x *ErrorHookResponse) String() string {
func (*ErrorHookResponse) ProtoMessage() {}
func (x *ErrorHookResponse) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[20]
+ mi := &file_pulumi_resource_proto_msgTypes[21]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2468,7 +2554,7 @@ func (x *ErrorHookResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use ErrorHookResponse.ProtoReflect.Descriptor instead.
func (*ErrorHookResponse) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{20}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{21}
}
func (x *ErrorHookResponse) GetError() string {
@@ -2499,7 +2585,7 @@ type RegisterPackageRequest struct {
func (x *RegisterPackageRequest) Reset() {
*x = RegisterPackageRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[21]
+ mi := &file_pulumi_resource_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2511,7 +2597,7 @@ func (x *RegisterPackageRequest) String() string {
func (*RegisterPackageRequest) ProtoMessage() {}
func (x *RegisterPackageRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[21]
+ mi := &file_pulumi_resource_proto_msgTypes[22]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2524,7 +2610,7 @@ func (x *RegisterPackageRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use RegisterPackageRequest.ProtoReflect.Descriptor instead.
func (*RegisterPackageRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{21}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{22}
}
func (x *RegisterPackageRequest) GetName() string {
@@ -2581,7 +2667,7 @@ type RegisterPackageResponse struct {
func (x *RegisterPackageResponse) Reset() {
*x = RegisterPackageResponse{}
- mi := &file_pulumi_resource_proto_msgTypes[22]
+ mi := &file_pulumi_resource_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2593,7 +2679,7 @@ func (x *RegisterPackageResponse) String() string {
func (*RegisterPackageResponse) ProtoMessage() {}
func (x *RegisterPackageResponse) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[22]
+ mi := &file_pulumi_resource_proto_msgTypes[23]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2606,7 +2692,7 @@ func (x *RegisterPackageResponse) ProtoReflect() protoreflect.Message {
// Deprecated: Use RegisterPackageResponse.ProtoReflect.Descriptor instead.
func (*RegisterPackageResponse) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{22}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{23}
}
func (x *RegisterPackageResponse) GetRef() string {
@@ -2627,7 +2713,7 @@ type Parameterization struct {
func (x *Parameterization) Reset() {
*x = Parameterization{}
- mi := &file_pulumi_resource_proto_msgTypes[23]
+ mi := &file_pulumi_resource_proto_msgTypes[24]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2639,7 +2725,7 @@ func (x *Parameterization) String() string {
func (*Parameterization) ProtoMessage() {}
func (x *Parameterization) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[23]
+ mi := &file_pulumi_resource_proto_msgTypes[24]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2652,7 +2738,7 @@ func (x *Parameterization) ProtoReflect() protoreflect.Message {
// Deprecated: Use Parameterization.ProtoReflect.Descriptor instead.
func (*Parameterization) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{23}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{24}
}
func (x *Parameterization) GetName() string {
@@ -2691,7 +2777,7 @@ type RegisterResourceHookRequest struct {
func (x *RegisterResourceHookRequest) Reset() {
*x = RegisterResourceHookRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[24]
+ mi := &file_pulumi_resource_proto_msgTypes[25]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2703,7 +2789,7 @@ func (x *RegisterResourceHookRequest) String() string {
func (*RegisterResourceHookRequest) ProtoMessage() {}
func (x *RegisterResourceHookRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[24]
+ mi := &file_pulumi_resource_proto_msgTypes[25]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2716,7 +2802,7 @@ func (x *RegisterResourceHookRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use RegisterResourceHookRequest.ProtoReflect.Descriptor instead.
func (*RegisterResourceHookRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{24}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{25}
}
func (x *RegisterResourceHookRequest) GetName() string {
@@ -2759,7 +2845,7 @@ type RegisterErrorHookRequest struct {
func (x *RegisterErrorHookRequest) Reset() {
*x = RegisterErrorHookRequest{}
- mi := &file_pulumi_resource_proto_msgTypes[25]
+ mi := &file_pulumi_resource_proto_msgTypes[26]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2771,7 +2857,7 @@ func (x *RegisterErrorHookRequest) String() string {
func (*RegisterErrorHookRequest) ProtoMessage() {}
func (x *RegisterErrorHookRequest) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[25]
+ mi := &file_pulumi_resource_proto_msgTypes[26]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2784,7 +2870,7 @@ func (x *RegisterErrorHookRequest) ProtoReflect() protoreflect.Message {
// Deprecated: Use RegisterErrorHookRequest.ProtoReflect.Descriptor instead.
func (*RegisterErrorHookRequest) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{25}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{26}
}
func (x *RegisterErrorHookRequest) GetName() string {
@@ -2811,7 +2897,7 @@ type RegisterResourceRequest_PropertyDependencies struct {
func (x *RegisterResourceRequest_PropertyDependencies) Reset() {
*x = RegisterResourceRequest_PropertyDependencies{}
- mi := &file_pulumi_resource_proto_msgTypes[28]
+ mi := &file_pulumi_resource_proto_msgTypes[29]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2823,7 +2909,7 @@ func (x *RegisterResourceRequest_PropertyDependencies) String() string {
func (*RegisterResourceRequest_PropertyDependencies) ProtoMessage() {}
func (x *RegisterResourceRequest_PropertyDependencies) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[28]
+ mi := &file_pulumi_resource_proto_msgTypes[29]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2859,7 +2945,7 @@ type RegisterResourceRequest_CustomTimeouts struct {
func (x *RegisterResourceRequest_CustomTimeouts) Reset() {
*x = RegisterResourceRequest_CustomTimeouts{}
- mi := &file_pulumi_resource_proto_msgTypes[29]
+ mi := &file_pulumi_resource_proto_msgTypes[30]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2871,7 +2957,7 @@ func (x *RegisterResourceRequest_CustomTimeouts) String() string {
func (*RegisterResourceRequest_CustomTimeouts) ProtoMessage() {}
func (x *RegisterResourceRequest_CustomTimeouts) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[29]
+ mi := &file_pulumi_resource_proto_msgTypes[30]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -2930,7 +3016,7 @@ type RegisterResourceRequest_ResourceHooksBinding struct {
func (x *RegisterResourceRequest_ResourceHooksBinding) Reset() {
*x = RegisterResourceRequest_ResourceHooksBinding{}
- mi := &file_pulumi_resource_proto_msgTypes[33]
+ mi := &file_pulumi_resource_proto_msgTypes[34]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -2942,7 +3028,7 @@ func (x *RegisterResourceRequest_ResourceHooksBinding) String() string {
func (*RegisterResourceRequest_ResourceHooksBinding) ProtoMessage() {}
func (x *RegisterResourceRequest_ResourceHooksBinding) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[33]
+ mi := &file_pulumi_resource_proto_msgTypes[34]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -3017,7 +3103,7 @@ type RegisterResourceResponse_PropertyDependencies struct {
func (x *RegisterResourceResponse_PropertyDependencies) Reset() {
*x = RegisterResourceResponse_PropertyDependencies{}
- mi := &file_pulumi_resource_proto_msgTypes[35]
+ mi := &file_pulumi_resource_proto_msgTypes[36]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -3029,7 +3115,7 @@ func (x *RegisterResourceResponse_PropertyDependencies) String() string {
func (*RegisterResourceResponse_PropertyDependencies) ProtoMessage() {}
func (x *RegisterResourceResponse_PropertyDependencies) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[35]
+ mi := &file_pulumi_resource_proto_msgTypes[36]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -3062,7 +3148,7 @@ type ResourceCallRequest_ArgumentDependencies struct {
func (x *ResourceCallRequest_ArgumentDependencies) Reset() {
*x = ResourceCallRequest_ArgumentDependencies{}
- mi := &file_pulumi_resource_proto_msgTypes[38]
+ mi := &file_pulumi_resource_proto_msgTypes[39]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -3074,7 +3160,7 @@ func (x *ResourceCallRequest_ArgumentDependencies) String() string {
func (*ResourceCallRequest_ArgumentDependencies) ProtoMessage() {}
func (x *ResourceCallRequest_ArgumentDependencies) ProtoReflect() protoreflect.Message {
- mi := &file_pulumi_resource_proto_msgTypes[38]
+ mi := &file_pulumi_resource_proto_msgTypes[39]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -3087,7 +3173,7 @@ func (x *ResourceCallRequest_ArgumentDependencies) ProtoReflect() protoreflect.M
// Deprecated: Use ResourceCallRequest_ArgumentDependencies.ProtoReflect.Descriptor instead.
func (*ResourceCallRequest_ArgumentDependencies) Descriptor() ([]byte, []int) {
- return file_pulumi_resource_proto_rawDescGZIP(), []int{9, 0}
+ return file_pulumi_resource_proto_rawDescGZIP(), []int{10, 0}
}
func (x *ResourceCallRequest_ArgumentDependencies) GetUrns() []string {
@@ -3236,7 +3322,7 @@ const file_pulumi_resource_proto_rawDesc = "" +
"\n" +
"\b_protectB\x11\n" +
"\x0f_retainOnDeleteB\b\n" +
- "\x06_hooks\"\xed\x03\n" +
+ "\x06_hooks\"\x87\x04\n" +
"\x18RegisterResourceResponse\x12\x10\n" +
"\x03urn\x18\x01 \x01(\tR\x03urn\x12\x0e\n" +
"\x02id\x18\x02 \x01(\tR\x02id\x12/\n" +
@@ -3244,7 +3330,8 @@ const file_pulumi_resource_proto_rawDesc = "" +
"\x06stable\x18\x04 \x01(\bR\x06stable\x12\x18\n" +
"\astables\x18\x05 \x03(\tR\astables\x12q\n" +
"\x14propertyDependencies\x18\x06 \x03(\v2=.pulumirpc.RegisterResourceResponse.PropertyDependenciesEntryR\x14propertyDependencies\x12)\n" +
- "\x06result\x18\a \x01(\x0e2\x11.pulumirpc.ResultR\x06result\x1a*\n" +
+ "\x06result\x18\a \x01(\x0e2\x11.pulumirpc.ResultR\x06result\x12\x18\n" +
+ "\aunknown\x18\b \x01(\bR\aunknown\x1a*\n" +
"\x14PropertyDependencies\x12\x12\n" +
"\x04urns\x18\x01 \x03(\tR\x04urns\x1a\x81\x01\n" +
"\x19PropertyDependenciesEntry\x12\x10\n" +
@@ -3252,7 +3339,7 @@ const file_pulumi_resource_proto_rawDesc = "" +
"\x05value\x18\x02 \x01(\v28.pulumirpc.RegisterResourceResponse.PropertyDependenciesR\x05value:\x028\x01\"e\n" +
"\x1eRegisterResourceOutputsRequest\x12\x10\n" +
"\x03urn\x18\x01 \x01(\tR\x03urn\x121\n" +
- "\aoutputs\x18\x02 \x01(\v2\x17.google.protobuf.StructR\aoutputs\"\xa3\x05\n" +
+ "\aoutputs\x18\x02 \x01(\v2\x17.google.protobuf.StructR\aoutputs\"\xc1\x05\n" +
"\x15ResourceInvokeRequest\x12\x10\n" +
"\x03tok\x18\x01 \x01(\tR\x03tok\x12+\n" +
"\x04args\x18\x02 \x01(\v2\x17.google.protobuf.StructR\x04args\x12\x1a\n" +
@@ -3270,11 +3357,16 @@ const file_pulumi_resource_proto_rawDesc = "" +
"\n" +
"packageRef\x18\t \x01(\tR\n" +
"packageRef\x12.\n" +
- "\x13accepts_byte_string\x18\f \x01(\bR\x11acceptsByteString\x12\x16\n" +
+ "\x13accepts_byte_string\x18\f \x01(\bR\x11acceptsByteString\x12\x1c\n" +
+ "\tdependsOn\x18\r \x03(\tR\tdependsOn\x12\x16\n" +
"\x06parent\x18\x0f \x01(\tR\x06parent\x1aB\n" +
"\x14PluginChecksumsEntry\x12\x10\n" +
"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
- "\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\"\xec\a\n" +
+ "\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\"\x98\x01\n" +
+ "\x16ResourceInvokeResponse\x12/\n" +
+ "\x06return\x18\x01 \x01(\v2\x17.google.protobuf.StructR\x06return\x123\n" +
+ "\bfailures\x18\x02 \x03(\v2\x17.pulumirpc.CheckFailureR\bfailures\x12\x18\n" +
+ "\aunknown\x18\x03 \x01(\bR\aunknown\"\xec\a\n" +
"\x13ResourceCallRequest\x12\x10\n" +
"\x03tok\x18\x01 \x01(\tR\x03tok\x12+\n" +
"\x04args\x18\x02 \x01(\v2\x17.google.protobuf.StructR\x04args\x12]\n" +
@@ -3465,7 +3557,7 @@ const file_pulumi_resource_proto_rawDesc = "" +
"\rignore_errors\x18\x04 \x01(\bR\fignoreErrors\"_\n" +
"\x18RegisterErrorHookRequest\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12/\n" +
- "\bcallback\x18\x02 \x01(\v2\x13.pulumirpc.CallbackR\bcallback*\xb8\x05\n" +
+ "\bcallback\x18\x02 \x01(\v2\x13.pulumirpc.CallbackR\bcallback*\xe8\x05\n" +
"\x16ResourceMonitorFeature\x12$\n" +
" RESOURCE_MONITOR_FEATURE_SECRETS\x10\x00\x120\n" +
",RESOURCE_MONITOR_FEATURE_RESOURCE_REFERENCES\x10\x01\x12*\n" +
@@ -3481,16 +3573,17 @@ const file_pulumi_resource_proto_rawDesc = "" +
"\x12(\n" +
"$RESOURCE_MONITOR_FEATURE_ERROR_HOOKS\x10\v\x123\n" +
"/RESOURCE_MONITOR_FEATURE_SENDS_OPTIONS_TO_HOOKS\x10\f\x12(\n" +
- "$RESOURCE_MONITOR_FEATURE_BYTE_STRING\x10\r\x12*\n" +
+ "$RESOURCE_MONITOR_FEATURE_BYTE_STRING\x10\r\x12.\n" +
+ "*RESOURCE_MONITOR_FEATURE_INVOKE_DEPENDS_ON\x10\x0e\x12*\n" +
"&RESOURCE_MONITOR_FEATURE_INVOKE_PARENT\x10\x0f*)\n" +
"\x06Result\x12\v\n" +
"\aSUCCESS\x10\x00\x12\b\n" +
"\x04FAIL\x10\x01\x12\b\n" +
- "\x04SKIP\x10\x022\xc5\b\n" +
+ "\x04SKIP\x10\x022\xcd\b\n" +
"\x0fResourceMonitor\x12H\n" +
"\x11GetDeploymentInfo\x12\x16.google.protobuf.Empty\x1a\x19.pulumirpc.DeploymentInfo\"\x00\x12Z\n" +
- "\x0fSupportsFeature\x12!.pulumirpc.SupportsFeatureRequest\x1a\".pulumirpc.SupportsFeatureResponse\"\x00\x12G\n" +
- "\x06Invoke\x12 .pulumirpc.ResourceInvokeRequest\x1a\x19.pulumirpc.InvokeResponse\"\x00\x12A\n" +
+ "\x0fSupportsFeature\x12!.pulumirpc.SupportsFeatureRequest\x1a\".pulumirpc.SupportsFeatureResponse\"\x00\x12O\n" +
+ "\x06Invoke\x12 .pulumirpc.ResourceInvokeRequest\x1a!.pulumirpc.ResourceInvokeResponse\"\x00\x12A\n" +
"\x04Call\x12\x1e.pulumirpc.ResourceCallRequest\x1a\x17.pulumirpc.CallResponse\"\x00\x12Q\n" +
"\fReadResource\x12\x1e.pulumirpc.ReadResourceRequest\x1a\x1f.pulumirpc.ReadResourceResponse\"\x00\x12]\n" +
"\x10RegisterResource\x12\".pulumirpc.RegisterResourceRequest\x1a#.pulumirpc.RegisterResourceResponse\"\x00\x12^\n" +
@@ -3515,7 +3608,7 @@ func file_pulumi_resource_proto_rawDescGZIP() []byte {
}
var file_pulumi_resource_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
-var file_pulumi_resource_proto_msgTypes = make([]protoimpl.MessageInfo, 47)
+var file_pulumi_resource_proto_msgTypes = make([]protoimpl.MessageInfo, 48)
var file_pulumi_resource_proto_goTypes = []any{
(ResourceMonitorFeature)(0), // 0: pulumirpc.ResourceMonitorFeature
(Result)(0), // 1: pulumirpc.Result
@@ -3528,158 +3621,161 @@ var file_pulumi_resource_proto_goTypes = []any{
(*RegisterResourceResponse)(nil), // 8: pulumirpc.RegisterResourceResponse
(*RegisterResourceOutputsRequest)(nil), // 9: pulumirpc.RegisterResourceOutputsRequest
(*ResourceInvokeRequest)(nil), // 10: pulumirpc.ResourceInvokeRequest
- (*ResourceCallRequest)(nil), // 11: pulumirpc.ResourceCallRequest
- (*TransformResourceOptions)(nil), // 12: pulumirpc.TransformResourceOptions
- (*ResourceOptions)(nil), // 13: pulumirpc.ResourceOptions
- (*TransformRequest)(nil), // 14: pulumirpc.TransformRequest
- (*TransformResponse)(nil), // 15: pulumirpc.TransformResponse
- (*TransformInvokeRequest)(nil), // 16: pulumirpc.TransformInvokeRequest
- (*TransformInvokeResponse)(nil), // 17: pulumirpc.TransformInvokeResponse
- (*TransformInvokeOptions)(nil), // 18: pulumirpc.TransformInvokeOptions
- (*ResourceHookRequest)(nil), // 19: pulumirpc.ResourceHookRequest
- (*ResourceHookResponse)(nil), // 20: pulumirpc.ResourceHookResponse
- (*ErrorHookRequest)(nil), // 21: pulumirpc.ErrorHookRequest
- (*ErrorHookResponse)(nil), // 22: pulumirpc.ErrorHookResponse
- (*RegisterPackageRequest)(nil), // 23: pulumirpc.RegisterPackageRequest
- (*RegisterPackageResponse)(nil), // 24: pulumirpc.RegisterPackageResponse
- (*Parameterization)(nil), // 25: pulumirpc.Parameterization
- (*RegisterResourceHookRequest)(nil), // 26: pulumirpc.RegisterResourceHookRequest
- (*RegisterErrorHookRequest)(nil), // 27: pulumirpc.RegisterErrorHookRequest
- nil, // 28: pulumirpc.DeploymentInfo.ConfigEntry
- nil, // 29: pulumirpc.ReadResourceRequest.PluginChecksumsEntry
- (*RegisterResourceRequest_PropertyDependencies)(nil), // 30: pulumirpc.RegisterResourceRequest.PropertyDependencies
- (*RegisterResourceRequest_CustomTimeouts)(nil), // 31: pulumirpc.RegisterResourceRequest.CustomTimeouts
- nil, // 32: pulumirpc.RegisterResourceRequest.PropertyDependenciesEntry
- nil, // 33: pulumirpc.RegisterResourceRequest.ProvidersEntry
- nil, // 34: pulumirpc.RegisterResourceRequest.PluginChecksumsEntry
- (*RegisterResourceRequest_ResourceHooksBinding)(nil), // 35: pulumirpc.RegisterResourceRequest.ResourceHooksBinding
- nil, // 36: pulumirpc.RegisterResourceRequest.EnvVarMappingsEntry
- (*RegisterResourceResponse_PropertyDependencies)(nil), // 37: pulumirpc.RegisterResourceResponse.PropertyDependencies
- nil, // 38: pulumirpc.RegisterResourceResponse.PropertyDependenciesEntry
- nil, // 39: pulumirpc.ResourceInvokeRequest.PluginChecksumsEntry
- (*ResourceCallRequest_ArgumentDependencies)(nil), // 40: pulumirpc.ResourceCallRequest.ArgumentDependencies
- nil, // 41: pulumirpc.ResourceCallRequest.ArgDependenciesEntry
- nil, // 42: pulumirpc.ResourceCallRequest.PluginChecksumsEntry
- nil, // 43: pulumirpc.TransformResourceOptions.ProvidersEntry
- nil, // 44: pulumirpc.TransformResourceOptions.PluginChecksumsEntry
- nil, // 45: pulumirpc.ResourceOptions.ProvidersEntry
- nil, // 46: pulumirpc.ResourceOptions.PluginChecksumsEntry
- nil, // 47: pulumirpc.TransformInvokeOptions.PluginChecksumsEntry
- nil, // 48: pulumirpc.RegisterPackageRequest.ChecksumsEntry
- (*structpb.Struct)(nil), // 49: google.protobuf.Struct
- (*SourcePosition)(nil), // 50: pulumirpc.SourcePosition
- (*StackTrace)(nil), // 51: pulumirpc.StackTrace
- (*Alias)(nil), // 52: pulumirpc.Alias
- (*structpb.Value)(nil), // 53: google.protobuf.Value
- (*Callback)(nil), // 54: pulumirpc.Callback
- (*emptypb.Empty)(nil), // 55: google.protobuf.Empty
- (*InvokeResponse)(nil), // 56: pulumirpc.InvokeResponse
- (*CallResponse)(nil), // 57: pulumirpc.CallResponse
+ (*ResourceInvokeResponse)(nil), // 11: pulumirpc.ResourceInvokeResponse
+ (*ResourceCallRequest)(nil), // 12: pulumirpc.ResourceCallRequest
+ (*TransformResourceOptions)(nil), // 13: pulumirpc.TransformResourceOptions
+ (*ResourceOptions)(nil), // 14: pulumirpc.ResourceOptions
+ (*TransformRequest)(nil), // 15: pulumirpc.TransformRequest
+ (*TransformResponse)(nil), // 16: pulumirpc.TransformResponse
+ (*TransformInvokeRequest)(nil), // 17: pulumirpc.TransformInvokeRequest
+ (*TransformInvokeResponse)(nil), // 18: pulumirpc.TransformInvokeResponse
+ (*TransformInvokeOptions)(nil), // 19: pulumirpc.TransformInvokeOptions
+ (*ResourceHookRequest)(nil), // 20: pulumirpc.ResourceHookRequest
+ (*ResourceHookResponse)(nil), // 21: pulumirpc.ResourceHookResponse
+ (*ErrorHookRequest)(nil), // 22: pulumirpc.ErrorHookRequest
+ (*ErrorHookResponse)(nil), // 23: pulumirpc.ErrorHookResponse
+ (*RegisterPackageRequest)(nil), // 24: pulumirpc.RegisterPackageRequest
+ (*RegisterPackageResponse)(nil), // 25: pulumirpc.RegisterPackageResponse
+ (*Parameterization)(nil), // 26: pulumirpc.Parameterization
+ (*RegisterResourceHookRequest)(nil), // 27: pulumirpc.RegisterResourceHookRequest
+ (*RegisterErrorHookRequest)(nil), // 28: pulumirpc.RegisterErrorHookRequest
+ nil, // 29: pulumirpc.DeploymentInfo.ConfigEntry
+ nil, // 30: pulumirpc.ReadResourceRequest.PluginChecksumsEntry
+ (*RegisterResourceRequest_PropertyDependencies)(nil), // 31: pulumirpc.RegisterResourceRequest.PropertyDependencies
+ (*RegisterResourceRequest_CustomTimeouts)(nil), // 32: pulumirpc.RegisterResourceRequest.CustomTimeouts
+ nil, // 33: pulumirpc.RegisterResourceRequest.PropertyDependenciesEntry
+ nil, // 34: pulumirpc.RegisterResourceRequest.ProvidersEntry
+ nil, // 35: pulumirpc.RegisterResourceRequest.PluginChecksumsEntry
+ (*RegisterResourceRequest_ResourceHooksBinding)(nil), // 36: pulumirpc.RegisterResourceRequest.ResourceHooksBinding
+ nil, // 37: pulumirpc.RegisterResourceRequest.EnvVarMappingsEntry
+ (*RegisterResourceResponse_PropertyDependencies)(nil), // 38: pulumirpc.RegisterResourceResponse.PropertyDependencies
+ nil, // 39: pulumirpc.RegisterResourceResponse.PropertyDependenciesEntry
+ nil, // 40: pulumirpc.ResourceInvokeRequest.PluginChecksumsEntry
+ (*ResourceCallRequest_ArgumentDependencies)(nil), // 41: pulumirpc.ResourceCallRequest.ArgumentDependencies
+ nil, // 42: pulumirpc.ResourceCallRequest.ArgDependenciesEntry
+ nil, // 43: pulumirpc.ResourceCallRequest.PluginChecksumsEntry
+ nil, // 44: pulumirpc.TransformResourceOptions.ProvidersEntry
+ nil, // 45: pulumirpc.TransformResourceOptions.PluginChecksumsEntry
+ nil, // 46: pulumirpc.ResourceOptions.ProvidersEntry
+ nil, // 47: pulumirpc.ResourceOptions.PluginChecksumsEntry
+ nil, // 48: pulumirpc.TransformInvokeOptions.PluginChecksumsEntry
+ nil, // 49: pulumirpc.RegisterPackageRequest.ChecksumsEntry
+ (*structpb.Struct)(nil), // 50: google.protobuf.Struct
+ (*SourcePosition)(nil), // 51: pulumirpc.SourcePosition
+ (*StackTrace)(nil), // 52: pulumirpc.StackTrace
+ (*Alias)(nil), // 53: pulumirpc.Alias
+ (*structpb.Value)(nil), // 54: google.protobuf.Value
+ (*Callback)(nil), // 55: pulumirpc.Callback
+ (*CheckFailure)(nil), // 56: pulumirpc.CheckFailure
+ (*emptypb.Empty)(nil), // 57: google.protobuf.Empty
+ (*CallResponse)(nil), // 58: pulumirpc.CallResponse
}
var file_pulumi_resource_proto_depIdxs = []int32{
- 28, // 0: pulumirpc.DeploymentInfo.config:type_name -> pulumirpc.DeploymentInfo.ConfigEntry
+ 29, // 0: pulumirpc.DeploymentInfo.config:type_name -> pulumirpc.DeploymentInfo.ConfigEntry
0, // 1: pulumirpc.DeploymentInfo.supportedFeatures:type_name -> pulumirpc.ResourceMonitorFeature
- 49, // 2: pulumirpc.ReadResourceRequest.properties:type_name -> google.protobuf.Struct
- 29, // 3: pulumirpc.ReadResourceRequest.pluginChecksums:type_name -> pulumirpc.ReadResourceRequest.PluginChecksumsEntry
- 50, // 4: pulumirpc.ReadResourceRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
- 51, // 5: pulumirpc.ReadResourceRequest.stackTrace:type_name -> pulumirpc.StackTrace
- 49, // 6: pulumirpc.ReadResourceResponse.properties:type_name -> google.protobuf.Struct
- 49, // 7: pulumirpc.RegisterResourceRequest.object:type_name -> google.protobuf.Struct
- 32, // 8: pulumirpc.RegisterResourceRequest.propertyDependencies:type_name -> pulumirpc.RegisterResourceRequest.PropertyDependenciesEntry
- 31, // 9: pulumirpc.RegisterResourceRequest.customTimeouts:type_name -> pulumirpc.RegisterResourceRequest.CustomTimeouts
- 33, // 10: pulumirpc.RegisterResourceRequest.providers:type_name -> pulumirpc.RegisterResourceRequest.ProvidersEntry
- 34, // 11: pulumirpc.RegisterResourceRequest.pluginChecksums:type_name -> pulumirpc.RegisterResourceRequest.PluginChecksumsEntry
- 52, // 12: pulumirpc.RegisterResourceRequest.aliases:type_name -> pulumirpc.Alias
- 53, // 13: pulumirpc.RegisterResourceRequest.replacement_trigger:type_name -> google.protobuf.Value
- 50, // 14: pulumirpc.RegisterResourceRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
- 51, // 15: pulumirpc.RegisterResourceRequest.stackTrace:type_name -> pulumirpc.StackTrace
- 54, // 16: pulumirpc.RegisterResourceRequest.transforms:type_name -> pulumirpc.Callback
- 35, // 17: pulumirpc.RegisterResourceRequest.hooks:type_name -> pulumirpc.RegisterResourceRequest.ResourceHooksBinding
- 36, // 18: pulumirpc.RegisterResourceRequest.envVarMappings:type_name -> pulumirpc.RegisterResourceRequest.EnvVarMappingsEntry
- 49, // 19: pulumirpc.RegisterResourceResponse.object:type_name -> google.protobuf.Struct
- 38, // 20: pulumirpc.RegisterResourceResponse.propertyDependencies:type_name -> pulumirpc.RegisterResourceResponse.PropertyDependenciesEntry
+ 50, // 2: pulumirpc.ReadResourceRequest.properties:type_name -> google.protobuf.Struct
+ 30, // 3: pulumirpc.ReadResourceRequest.pluginChecksums:type_name -> pulumirpc.ReadResourceRequest.PluginChecksumsEntry
+ 51, // 4: pulumirpc.ReadResourceRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
+ 52, // 5: pulumirpc.ReadResourceRequest.stackTrace:type_name -> pulumirpc.StackTrace
+ 50, // 6: pulumirpc.ReadResourceResponse.properties:type_name -> google.protobuf.Struct
+ 50, // 7: pulumirpc.RegisterResourceRequest.object:type_name -> google.protobuf.Struct
+ 33, // 8: pulumirpc.RegisterResourceRequest.propertyDependencies:type_name -> pulumirpc.RegisterResourceRequest.PropertyDependenciesEntry
+ 32, // 9: pulumirpc.RegisterResourceRequest.customTimeouts:type_name -> pulumirpc.RegisterResourceRequest.CustomTimeouts
+ 34, // 10: pulumirpc.RegisterResourceRequest.providers:type_name -> pulumirpc.RegisterResourceRequest.ProvidersEntry
+ 35, // 11: pulumirpc.RegisterResourceRequest.pluginChecksums:type_name -> pulumirpc.RegisterResourceRequest.PluginChecksumsEntry
+ 53, // 12: pulumirpc.RegisterResourceRequest.aliases:type_name -> pulumirpc.Alias
+ 54, // 13: pulumirpc.RegisterResourceRequest.replacement_trigger:type_name -> google.protobuf.Value
+ 51, // 14: pulumirpc.RegisterResourceRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
+ 52, // 15: pulumirpc.RegisterResourceRequest.stackTrace:type_name -> pulumirpc.StackTrace
+ 55, // 16: pulumirpc.RegisterResourceRequest.transforms:type_name -> pulumirpc.Callback
+ 36, // 17: pulumirpc.RegisterResourceRequest.hooks:type_name -> pulumirpc.RegisterResourceRequest.ResourceHooksBinding
+ 37, // 18: pulumirpc.RegisterResourceRequest.envVarMappings:type_name -> pulumirpc.RegisterResourceRequest.EnvVarMappingsEntry
+ 50, // 19: pulumirpc.RegisterResourceResponse.object:type_name -> google.protobuf.Struct
+ 39, // 20: pulumirpc.RegisterResourceResponse.propertyDependencies:type_name -> pulumirpc.RegisterResourceResponse.PropertyDependenciesEntry
1, // 21: pulumirpc.RegisterResourceResponse.result:type_name -> pulumirpc.Result
- 49, // 22: pulumirpc.RegisterResourceOutputsRequest.outputs:type_name -> google.protobuf.Struct
- 49, // 23: pulumirpc.ResourceInvokeRequest.args:type_name -> google.protobuf.Struct
- 39, // 24: pulumirpc.ResourceInvokeRequest.pluginChecksums:type_name -> pulumirpc.ResourceInvokeRequest.PluginChecksumsEntry
- 50, // 25: pulumirpc.ResourceInvokeRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
- 51, // 26: pulumirpc.ResourceInvokeRequest.stackTrace:type_name -> pulumirpc.StackTrace
- 49, // 27: pulumirpc.ResourceCallRequest.args:type_name -> google.protobuf.Struct
- 41, // 28: pulumirpc.ResourceCallRequest.argDependencies:type_name -> pulumirpc.ResourceCallRequest.ArgDependenciesEntry
- 42, // 29: pulumirpc.ResourceCallRequest.pluginChecksums:type_name -> pulumirpc.ResourceCallRequest.PluginChecksumsEntry
- 50, // 30: pulumirpc.ResourceCallRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
- 51, // 31: pulumirpc.ResourceCallRequest.stackTrace:type_name -> pulumirpc.StackTrace
- 52, // 32: pulumirpc.TransformResourceOptions.aliases:type_name -> pulumirpc.Alias
- 31, // 33: pulumirpc.TransformResourceOptions.custom_timeouts:type_name -> pulumirpc.RegisterResourceRequest.CustomTimeouts
- 43, // 34: pulumirpc.TransformResourceOptions.providers:type_name -> pulumirpc.TransformResourceOptions.ProvidersEntry
- 44, // 35: pulumirpc.TransformResourceOptions.plugin_checksums:type_name -> pulumirpc.TransformResourceOptions.PluginChecksumsEntry
- 35, // 36: pulumirpc.TransformResourceOptions.hooks:type_name -> pulumirpc.RegisterResourceRequest.ResourceHooksBinding
- 53, // 37: pulumirpc.TransformResourceOptions.replacement_trigger:type_name -> google.protobuf.Value
- 52, // 38: pulumirpc.ResourceOptions.aliases:type_name -> pulumirpc.Alias
- 31, // 39: pulumirpc.ResourceOptions.custom_timeouts:type_name -> pulumirpc.RegisterResourceRequest.CustomTimeouts
- 45, // 40: pulumirpc.ResourceOptions.providers:type_name -> pulumirpc.ResourceOptions.ProvidersEntry
- 46, // 41: pulumirpc.ResourceOptions.plugin_checksums:type_name -> pulumirpc.ResourceOptions.PluginChecksumsEntry
- 35, // 42: pulumirpc.ResourceOptions.hooks:type_name -> pulumirpc.RegisterResourceRequest.ResourceHooksBinding
- 53, // 43: pulumirpc.ResourceOptions.replacement_trigger:type_name -> google.protobuf.Value
- 49, // 44: pulumirpc.TransformRequest.properties:type_name -> google.protobuf.Struct
- 12, // 45: pulumirpc.TransformRequest.options:type_name -> pulumirpc.TransformResourceOptions
- 49, // 46: pulumirpc.TransformResponse.properties:type_name -> google.protobuf.Struct
- 12, // 47: pulumirpc.TransformResponse.options:type_name -> pulumirpc.TransformResourceOptions
- 49, // 48: pulumirpc.TransformInvokeRequest.args:type_name -> google.protobuf.Struct
- 18, // 49: pulumirpc.TransformInvokeRequest.options:type_name -> pulumirpc.TransformInvokeOptions
- 49, // 50: pulumirpc.TransformInvokeResponse.args:type_name -> google.protobuf.Struct
- 18, // 51: pulumirpc.TransformInvokeResponse.options:type_name -> pulumirpc.TransformInvokeOptions
- 47, // 52: pulumirpc.TransformInvokeOptions.plugin_checksums:type_name -> pulumirpc.TransformInvokeOptions.PluginChecksumsEntry
- 49, // 53: pulumirpc.ResourceHookRequest.new_inputs:type_name -> google.protobuf.Struct
- 49, // 54: pulumirpc.ResourceHookRequest.old_inputs:type_name -> google.protobuf.Struct
- 49, // 55: pulumirpc.ResourceHookRequest.new_outputs:type_name -> google.protobuf.Struct
- 49, // 56: pulumirpc.ResourceHookRequest.old_outputs:type_name -> google.protobuf.Struct
- 13, // 57: pulumirpc.ResourceHookRequest.old_options:type_name -> pulumirpc.ResourceOptions
- 13, // 58: pulumirpc.ResourceHookRequest.new_options:type_name -> pulumirpc.ResourceOptions
- 49, // 59: pulumirpc.ErrorHookRequest.new_inputs:type_name -> google.protobuf.Struct
- 49, // 60: pulumirpc.ErrorHookRequest.old_inputs:type_name -> google.protobuf.Struct
- 49, // 61: pulumirpc.ErrorHookRequest.old_outputs:type_name -> google.protobuf.Struct
- 13, // 62: pulumirpc.ErrorHookRequest.old_options:type_name -> pulumirpc.ResourceOptions
- 13, // 63: pulumirpc.ErrorHookRequest.new_options:type_name -> pulumirpc.ResourceOptions
- 48, // 64: pulumirpc.RegisterPackageRequest.checksums:type_name -> pulumirpc.RegisterPackageRequest.ChecksumsEntry
- 25, // 65: pulumirpc.RegisterPackageRequest.parameterization:type_name -> pulumirpc.Parameterization
- 25, // 66: pulumirpc.RegisterPackageRequest.extension:type_name -> pulumirpc.Parameterization
- 54, // 67: pulumirpc.RegisterResourceHookRequest.callback:type_name -> pulumirpc.Callback
- 54, // 68: pulumirpc.RegisterErrorHookRequest.callback:type_name -> pulumirpc.Callback
- 30, // 69: pulumirpc.RegisterResourceRequest.PropertyDependenciesEntry.value:type_name -> pulumirpc.RegisterResourceRequest.PropertyDependencies
- 37, // 70: pulumirpc.RegisterResourceResponse.PropertyDependenciesEntry.value:type_name -> pulumirpc.RegisterResourceResponse.PropertyDependencies
- 40, // 71: pulumirpc.ResourceCallRequest.ArgDependenciesEntry.value:type_name -> pulumirpc.ResourceCallRequest.ArgumentDependencies
- 55, // 72: pulumirpc.ResourceMonitor.GetDeploymentInfo:input_type -> google.protobuf.Empty
- 3, // 73: pulumirpc.ResourceMonitor.SupportsFeature:input_type -> pulumirpc.SupportsFeatureRequest
- 10, // 74: pulumirpc.ResourceMonitor.Invoke:input_type -> pulumirpc.ResourceInvokeRequest
- 11, // 75: pulumirpc.ResourceMonitor.Call:input_type -> pulumirpc.ResourceCallRequest
- 5, // 76: pulumirpc.ResourceMonitor.ReadResource:input_type -> pulumirpc.ReadResourceRequest
- 7, // 77: pulumirpc.ResourceMonitor.RegisterResource:input_type -> pulumirpc.RegisterResourceRequest
- 9, // 78: pulumirpc.ResourceMonitor.RegisterResourceOutputs:input_type -> pulumirpc.RegisterResourceOutputsRequest
- 54, // 79: pulumirpc.ResourceMonitor.RegisterStackTransform:input_type -> pulumirpc.Callback
- 54, // 80: pulumirpc.ResourceMonitor.RegisterStackInvokeTransform:input_type -> pulumirpc.Callback
- 26, // 81: pulumirpc.ResourceMonitor.RegisterResourceHook:input_type -> pulumirpc.RegisterResourceHookRequest
- 27, // 82: pulumirpc.ResourceMonitor.RegisterErrorHook:input_type -> pulumirpc.RegisterErrorHookRequest
- 23, // 83: pulumirpc.ResourceMonitor.RegisterPackage:input_type -> pulumirpc.RegisterPackageRequest
- 55, // 84: pulumirpc.ResourceMonitor.SignalAndWaitForShutdown:input_type -> google.protobuf.Empty
- 2, // 85: pulumirpc.ResourceMonitor.GetDeploymentInfo:output_type -> pulumirpc.DeploymentInfo
- 4, // 86: pulumirpc.ResourceMonitor.SupportsFeature:output_type -> pulumirpc.SupportsFeatureResponse
- 56, // 87: pulumirpc.ResourceMonitor.Invoke:output_type -> pulumirpc.InvokeResponse
- 57, // 88: pulumirpc.ResourceMonitor.Call:output_type -> pulumirpc.CallResponse
- 6, // 89: pulumirpc.ResourceMonitor.ReadResource:output_type -> pulumirpc.ReadResourceResponse
- 8, // 90: pulumirpc.ResourceMonitor.RegisterResource:output_type -> pulumirpc.RegisterResourceResponse
- 55, // 91: pulumirpc.ResourceMonitor.RegisterResourceOutputs:output_type -> google.protobuf.Empty
- 55, // 92: pulumirpc.ResourceMonitor.RegisterStackTransform:output_type -> google.protobuf.Empty
- 55, // 93: pulumirpc.ResourceMonitor.RegisterStackInvokeTransform:output_type -> google.protobuf.Empty
- 55, // 94: pulumirpc.ResourceMonitor.RegisterResourceHook:output_type -> google.protobuf.Empty
- 55, // 95: pulumirpc.ResourceMonitor.RegisterErrorHook:output_type -> google.protobuf.Empty
- 24, // 96: pulumirpc.ResourceMonitor.RegisterPackage:output_type -> pulumirpc.RegisterPackageResponse
- 55, // 97: pulumirpc.ResourceMonitor.SignalAndWaitForShutdown:output_type -> google.protobuf.Empty
- 85, // [85:98] is the sub-list for method output_type
- 72, // [72:85] is the sub-list for method input_type
- 72, // [72:72] is the sub-list for extension type_name
- 72, // [72:72] is the sub-list for extension extendee
- 0, // [0:72] is the sub-list for field type_name
+ 50, // 22: pulumirpc.RegisterResourceOutputsRequest.outputs:type_name -> google.protobuf.Struct
+ 50, // 23: pulumirpc.ResourceInvokeRequest.args:type_name -> google.protobuf.Struct
+ 40, // 24: pulumirpc.ResourceInvokeRequest.pluginChecksums:type_name -> pulumirpc.ResourceInvokeRequest.PluginChecksumsEntry
+ 51, // 25: pulumirpc.ResourceInvokeRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
+ 52, // 26: pulumirpc.ResourceInvokeRequest.stackTrace:type_name -> pulumirpc.StackTrace
+ 50, // 27: pulumirpc.ResourceInvokeResponse.return:type_name -> google.protobuf.Struct
+ 56, // 28: pulumirpc.ResourceInvokeResponse.failures:type_name -> pulumirpc.CheckFailure
+ 50, // 29: pulumirpc.ResourceCallRequest.args:type_name -> google.protobuf.Struct
+ 42, // 30: pulumirpc.ResourceCallRequest.argDependencies:type_name -> pulumirpc.ResourceCallRequest.ArgDependenciesEntry
+ 43, // 31: pulumirpc.ResourceCallRequest.pluginChecksums:type_name -> pulumirpc.ResourceCallRequest.PluginChecksumsEntry
+ 51, // 32: pulumirpc.ResourceCallRequest.sourcePosition:type_name -> pulumirpc.SourcePosition
+ 52, // 33: pulumirpc.ResourceCallRequest.stackTrace:type_name -> pulumirpc.StackTrace
+ 53, // 34: pulumirpc.TransformResourceOptions.aliases:type_name -> pulumirpc.Alias
+ 32, // 35: pulumirpc.TransformResourceOptions.custom_timeouts:type_name -> pulumirpc.RegisterResourceRequest.CustomTimeouts
+ 44, // 36: pulumirpc.TransformResourceOptions.providers:type_name -> pulumirpc.TransformResourceOptions.ProvidersEntry
+ 45, // 37: pulumirpc.TransformResourceOptions.plugin_checksums:type_name -> pulumirpc.TransformResourceOptions.PluginChecksumsEntry
+ 36, // 38: pulumirpc.TransformResourceOptions.hooks:type_name -> pulumirpc.RegisterResourceRequest.ResourceHooksBinding
+ 54, // 39: pulumirpc.TransformResourceOptions.replacement_trigger:type_name -> google.protobuf.Value
+ 53, // 40: pulumirpc.ResourceOptions.aliases:type_name -> pulumirpc.Alias
+ 32, // 41: pulumirpc.ResourceOptions.custom_timeouts:type_name -> pulumirpc.RegisterResourceRequest.CustomTimeouts
+ 46, // 42: pulumirpc.ResourceOptions.providers:type_name -> pulumirpc.ResourceOptions.ProvidersEntry
+ 47, // 43: pulumirpc.ResourceOptions.plugin_checksums:type_name -> pulumirpc.ResourceOptions.PluginChecksumsEntry
+ 36, // 44: pulumirpc.ResourceOptions.hooks:type_name -> pulumirpc.RegisterResourceRequest.ResourceHooksBinding
+ 54, // 45: pulumirpc.ResourceOptions.replacement_trigger:type_name -> google.protobuf.Value
+ 50, // 46: pulumirpc.TransformRequest.properties:type_name -> google.protobuf.Struct
+ 13, // 47: pulumirpc.TransformRequest.options:type_name -> pulumirpc.TransformResourceOptions
+ 50, // 48: pulumirpc.TransformResponse.properties:type_name -> google.protobuf.Struct
+ 13, // 49: pulumirpc.TransformResponse.options:type_name -> pulumirpc.TransformResourceOptions
+ 50, // 50: pulumirpc.TransformInvokeRequest.args:type_name -> google.protobuf.Struct
+ 19, // 51: pulumirpc.TransformInvokeRequest.options:type_name -> pulumirpc.TransformInvokeOptions
+ 50, // 52: pulumirpc.TransformInvokeResponse.args:type_name -> google.protobuf.Struct
+ 19, // 53: pulumirpc.TransformInvokeResponse.options:type_name -> pulumirpc.TransformInvokeOptions
+ 48, // 54: pulumirpc.TransformInvokeOptions.plugin_checksums:type_name -> pulumirpc.TransformInvokeOptions.PluginChecksumsEntry
+ 50, // 55: pulumirpc.ResourceHookRequest.new_inputs:type_name -> google.protobuf.Struct
+ 50, // 56: pulumirpc.ResourceHookRequest.old_inputs:type_name -> google.protobuf.Struct
+ 50, // 57: pulumirpc.ResourceHookRequest.new_outputs:type_name -> google.protobuf.Struct
+ 50, // 58: pulumirpc.ResourceHookRequest.old_outputs:type_name -> google.protobuf.Struct
+ 14, // 59: pulumirpc.ResourceHookRequest.old_options:type_name -> pulumirpc.ResourceOptions
+ 14, // 60: pulumirpc.ResourceHookRequest.new_options:type_name -> pulumirpc.ResourceOptions
+ 50, // 61: pulumirpc.ErrorHookRequest.new_inputs:type_name -> google.protobuf.Struct
+ 50, // 62: pulumirpc.ErrorHookRequest.old_inputs:type_name -> google.protobuf.Struct
+ 50, // 63: pulumirpc.ErrorHookRequest.old_outputs:type_name -> google.protobuf.Struct
+ 14, // 64: pulumirpc.ErrorHookRequest.old_options:type_name -> pulumirpc.ResourceOptions
+ 14, // 65: pulumirpc.ErrorHookRequest.new_options:type_name -> pulumirpc.ResourceOptions
+ 49, // 66: pulumirpc.RegisterPackageRequest.checksums:type_name -> pulumirpc.RegisterPackageRequest.ChecksumsEntry
+ 26, // 67: pulumirpc.RegisterPackageRequest.parameterization:type_name -> pulumirpc.Parameterization
+ 26, // 68: pulumirpc.RegisterPackageRequest.extension:type_name -> pulumirpc.Parameterization
+ 55, // 69: pulumirpc.RegisterResourceHookRequest.callback:type_name -> pulumirpc.Callback
+ 55, // 70: pulumirpc.RegisterErrorHookRequest.callback:type_name -> pulumirpc.Callback
+ 31, // 71: pulumirpc.RegisterResourceRequest.PropertyDependenciesEntry.value:type_name -> pulumirpc.RegisterResourceRequest.PropertyDependencies
+ 38, // 72: pulumirpc.RegisterResourceResponse.PropertyDependenciesEntry.value:type_name -> pulumirpc.RegisterResourceResponse.PropertyDependencies
+ 41, // 73: pulumirpc.ResourceCallRequest.ArgDependenciesEntry.value:type_name -> pulumirpc.ResourceCallRequest.ArgumentDependencies
+ 57, // 74: pulumirpc.ResourceMonitor.GetDeploymentInfo:input_type -> google.protobuf.Empty
+ 3, // 75: pulumirpc.ResourceMonitor.SupportsFeature:input_type -> pulumirpc.SupportsFeatureRequest
+ 10, // 76: pulumirpc.ResourceMonitor.Invoke:input_type -> pulumirpc.ResourceInvokeRequest
+ 12, // 77: pulumirpc.ResourceMonitor.Call:input_type -> pulumirpc.ResourceCallRequest
+ 5, // 78: pulumirpc.ResourceMonitor.ReadResource:input_type -> pulumirpc.ReadResourceRequest
+ 7, // 79: pulumirpc.ResourceMonitor.RegisterResource:input_type -> pulumirpc.RegisterResourceRequest
+ 9, // 80: pulumirpc.ResourceMonitor.RegisterResourceOutputs:input_type -> pulumirpc.RegisterResourceOutputsRequest
+ 55, // 81: pulumirpc.ResourceMonitor.RegisterStackTransform:input_type -> pulumirpc.Callback
+ 55, // 82: pulumirpc.ResourceMonitor.RegisterStackInvokeTransform:input_type -> pulumirpc.Callback
+ 27, // 83: pulumirpc.ResourceMonitor.RegisterResourceHook:input_type -> pulumirpc.RegisterResourceHookRequest
+ 28, // 84: pulumirpc.ResourceMonitor.RegisterErrorHook:input_type -> pulumirpc.RegisterErrorHookRequest
+ 24, // 85: pulumirpc.ResourceMonitor.RegisterPackage:input_type -> pulumirpc.RegisterPackageRequest
+ 57, // 86: pulumirpc.ResourceMonitor.SignalAndWaitForShutdown:input_type -> google.protobuf.Empty
+ 2, // 87: pulumirpc.ResourceMonitor.GetDeploymentInfo:output_type -> pulumirpc.DeploymentInfo
+ 4, // 88: pulumirpc.ResourceMonitor.SupportsFeature:output_type -> pulumirpc.SupportsFeatureResponse
+ 11, // 89: pulumirpc.ResourceMonitor.Invoke:output_type -> pulumirpc.ResourceInvokeResponse
+ 58, // 90: pulumirpc.ResourceMonitor.Call:output_type -> pulumirpc.CallResponse
+ 6, // 91: pulumirpc.ResourceMonitor.ReadResource:output_type -> pulumirpc.ReadResourceResponse
+ 8, // 92: pulumirpc.ResourceMonitor.RegisterResource:output_type -> pulumirpc.RegisterResourceResponse
+ 57, // 93: pulumirpc.ResourceMonitor.RegisterResourceOutputs:output_type -> google.protobuf.Empty
+ 57, // 94: pulumirpc.ResourceMonitor.RegisterStackTransform:output_type -> google.protobuf.Empty
+ 57, // 95: pulumirpc.ResourceMonitor.RegisterStackInvokeTransform:output_type -> google.protobuf.Empty
+ 57, // 96: pulumirpc.ResourceMonitor.RegisterResourceHook:output_type -> google.protobuf.Empty
+ 57, // 97: pulumirpc.ResourceMonitor.RegisterErrorHook:output_type -> google.protobuf.Empty
+ 25, // 98: pulumirpc.ResourceMonitor.RegisterPackage:output_type -> pulumirpc.RegisterPackageResponse
+ 57, // 99: pulumirpc.ResourceMonitor.SignalAndWaitForShutdown:output_type -> google.protobuf.Empty
+ 87, // [87:100] is the sub-list for method output_type
+ 74, // [74:87] is the sub-list for method input_type
+ 74, // [74:74] is the sub-list for extension type_name
+ 74, // [74:74] is the sub-list for extension extendee
+ 0, // [0:74] is the sub-list for field type_name
}
func init() { file_pulumi_resource_proto_init() }
@@ -3692,16 +3788,16 @@ func file_pulumi_resource_proto_init() {
file_pulumi_source_proto_init()
file_pulumi_callback_proto_init()
file_pulumi_resource_proto_msgTypes[5].OneofWrappers = []any{}
- file_pulumi_resource_proto_msgTypes[10].OneofWrappers = []any{}
file_pulumi_resource_proto_msgTypes[11].OneofWrappers = []any{}
- file_pulumi_resource_proto_msgTypes[17].OneofWrappers = []any{}
+ file_pulumi_resource_proto_msgTypes[12].OneofWrappers = []any{}
+ file_pulumi_resource_proto_msgTypes[18].OneofWrappers = []any{}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_pulumi_resource_proto_rawDesc), len(file_pulumi_resource_proto_rawDesc)),
NumEnums: 2,
- NumMessages: 47,
+ NumMessages: 48,
NumExtensions: 0,
NumServices: 1,
},
diff --git a/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource_grpc.pb.go b/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource_grpc.pb.go
index da99cf94b..6721926b1 100644
--- a/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource_grpc.pb.go
+++ b/vendor/github.com/pulumi/pulumi/sdk/v3/proto/go/resource_grpc.pb.go
@@ -66,7 +66,7 @@ type ResourceMonitorClient interface {
// - Clients should fall back to existing request fields/env vars/SupportsFeature.
GetDeploymentInfo(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*DeploymentInfo, error)
SupportsFeature(ctx context.Context, in *SupportsFeatureRequest, opts ...grpc.CallOption) (*SupportsFeatureResponse, error)
- Invoke(ctx context.Context, in *ResourceInvokeRequest, opts ...grpc.CallOption) (*InvokeResponse, error)
+ Invoke(ctx context.Context, in *ResourceInvokeRequest, opts ...grpc.CallOption) (*ResourceInvokeResponse, error)
Call(ctx context.Context, in *ResourceCallRequest, opts ...grpc.CallOption) (*CallResponse, error)
ReadResource(ctx context.Context, in *ReadResourceRequest, opts ...grpc.CallOption) (*ReadResourceResponse, error)
RegisterResource(ctx context.Context, in *RegisterResourceRequest, opts ...grpc.CallOption) (*RegisterResourceResponse, error)
@@ -122,9 +122,9 @@ func (c *resourceMonitorClient) SupportsFeature(ctx context.Context, in *Support
return out, nil
}
-func (c *resourceMonitorClient) Invoke(ctx context.Context, in *ResourceInvokeRequest, opts ...grpc.CallOption) (*InvokeResponse, error) {
+func (c *resourceMonitorClient) Invoke(ctx context.Context, in *ResourceInvokeRequest, opts ...grpc.CallOption) (*ResourceInvokeResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
- out := new(InvokeResponse)
+ out := new(ResourceInvokeResponse)
err := c.cc.Invoke(ctx, ResourceMonitor_Invoke_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
@@ -249,7 +249,7 @@ type ResourceMonitorServer interface {
// - Clients should fall back to existing request fields/env vars/SupportsFeature.
GetDeploymentInfo(context.Context, *emptypb.Empty) (*DeploymentInfo, error)
SupportsFeature(context.Context, *SupportsFeatureRequest) (*SupportsFeatureResponse, error)
- Invoke(context.Context, *ResourceInvokeRequest) (*InvokeResponse, error)
+ Invoke(context.Context, *ResourceInvokeRequest) (*ResourceInvokeResponse, error)
Call(context.Context, *ResourceCallRequest) (*CallResponse, error)
ReadResource(context.Context, *ReadResourceRequest) (*ReadResourceResponse, error)
RegisterResource(context.Context, *RegisterResourceRequest) (*RegisterResourceResponse, error)
@@ -291,7 +291,7 @@ func (UnimplementedResourceMonitorServer) GetDeploymentInfo(context.Context, *em
func (UnimplementedResourceMonitorServer) SupportsFeature(context.Context, *SupportsFeatureRequest) (*SupportsFeatureResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method SupportsFeature not implemented")
}
-func (UnimplementedResourceMonitorServer) Invoke(context.Context, *ResourceInvokeRequest) (*InvokeResponse, error) {
+func (UnimplementedResourceMonitorServer) Invoke(context.Context, *ResourceInvokeRequest) (*ResourceInvokeResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Invoke not implemented")
}
func (UnimplementedResourceMonitorServer) Call(context.Context, *ResourceCallRequest) (*CallResponse, error) {
diff --git a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/convert.go b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/convert.go
index cf98f8511..8d4556437 100644
--- a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/convert.go
+++ b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/convert.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/logutil/convert.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otelslog // import "go.opentelemetry.io/contrib/bridges/otelslog"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/logutil/convert.go.tmpl
+
+package otelslog
import (
"fmt"
@@ -14,81 +14,78 @@ import (
"time"
"go.opentelemetry.io/otel/attribute"
- "go.opentelemetry.io/otel/log"
)
-// convertValue converts various types to log.Value.
-func convertValue(v any) log.Value {
+// convertValue converts various types to attribute.Value.
+func convertValue(v any) attribute.Value {
// Handling the most common types without reflect is a small perf win.
switch val := v.(type) {
case bool:
- return log.BoolValue(val)
+ return attribute.BoolValue(val)
case string:
- return log.StringValue(val)
+ return attribute.StringValue(val)
case int:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case int8:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case int16:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case int32:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case int64:
- return log.Int64Value(val)
+ return attribute.Int64Value(val)
case uint:
return convertUintValue(uint64(val))
case uint8:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case uint16:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case uint32:
- return log.Int64Value(int64(val))
+ return attribute.Int64Value(int64(val))
case uint64:
return convertUintValue(val)
case uintptr:
return convertUintValue(uint64(val))
case float32:
- return log.Float64Value(float64(val))
+ return attribute.Float64Value(float64(val))
case float64:
- return log.Float64Value(val)
+ return attribute.Float64Value(val)
case time.Duration:
- return log.Int64Value(val.Nanoseconds())
+ return attribute.Int64Value(val.Nanoseconds())
case complex64:
- r := log.Float64("r", real(complex128(val)))
- i := log.Float64("i", imag(complex128(val)))
- return log.MapValue(r, i)
+ r := attribute.Float64("r", real(complex128(val)))
+ i := attribute.Float64("i", imag(complex128(val)))
+ return attribute.MapValue(r, i)
case complex128:
- r := log.Float64("r", real(val))
- i := log.Float64("i", imag(val))
- return log.MapValue(r, i)
+ r := attribute.Float64("r", real(val))
+ i := attribute.Float64("i", imag(val))
+ return attribute.MapValue(r, i)
case time.Time:
- return log.Int64Value(val.UnixNano())
+ return attribute.Int64Value(val.UnixNano())
case []byte:
- return log.BytesValue(val)
+ return attribute.ByteSliceValue(val)
case error:
- return log.StringValue(val.Error())
+ return attribute.StringValue(val.Error())
case attribute.Value:
- return log.ValueFromAttribute(val)
- case log.Value:
return val
}
t := reflect.TypeOf(v)
if t == nil {
- return log.Value{}
+ return attribute.Value{}
}
val := reflect.ValueOf(v)
switch t.Kind() {
case reflect.Struct:
- return log.StringValue(fmt.Sprintf("%+v", v))
+ return attribute.StringValue(fmt.Sprintf("%+v", v))
case reflect.Slice, reflect.Array:
- items := make([]log.Value, 0, val.Len())
- for i := 0; i < val.Len(); i++ {
+ items := make([]attribute.Value, 0, val.Len())
+ for i := range val.Len() {
items = append(items, convertValue(val.Index(i).Interface()))
}
- return log.SliceValue(items...)
+ return attribute.SliceValue(items...)
case reflect.Map:
- kvs := make([]log.KeyValue, 0, val.Len())
+ kvs := make([]attribute.KeyValue, 0, val.Len())
for _, k := range val.MapKeys() {
var key string
switch k.Kind() {
@@ -97,15 +94,15 @@ func convertValue(v any) log.Value {
default:
key = fmt.Sprintf("%+v", k.Interface())
}
- kvs = append(kvs, log.KeyValue{
- Key: key,
+ kvs = append(kvs, attribute.KeyValue{
+ Key: attribute.Key(key),
Value: convertValue(val.MapIndex(k).Interface()),
})
}
- return log.MapValue(kvs...)
- case reflect.Ptr, reflect.Interface:
+ return attribute.MapValue(kvs...)
+ case reflect.Pointer, reflect.Interface:
if val.IsNil() {
- return log.Value{}
+ return attribute.Value{}
}
return convertValue(val.Elem().Interface())
}
@@ -115,14 +112,14 @@ func convertValue(v any) log.Value {
// Don't panic here. it is preferable to have user's open issue
// asking why their attributes have a "unhandled: " prefix than
// say that their code is panicking.
- return log.StringValue(fmt.Sprintf("unhandled: (%s) %+v", t, v))
+ return attribute.StringValue(fmt.Sprintf("unhandled: (%s) %+v", t, v))
}
-// convertUintValue converts a uint64 to a log.Value.
+// convertUintValue converts a uint64 to an attribute.Value.
// If the value is too large to fit in an int64, it is converted to a string.
-func convertUintValue(v uint64) log.Value {
+func convertUintValue(v uint64) attribute.Value {
if v > math.MaxInt64 {
- return log.StringValue(strconv.FormatUint(v, 10))
+ return attribute.StringValue(strconv.FormatUint(v, 10))
}
- return log.Int64Value(int64(v))
+ return attribute.Int64Value(int64(v))
}
diff --git a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/gen.go b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/gen.go
index 14dba573a..67b5778cd 100644
--- a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/gen.go
+++ b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/gen.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otelslog // import "go.opentelemetry.io/contrib/bridges/otelslog"
+package otelslog
// Generate convert:
//go:generate gotmpl --body=../../internal/shared/logutil/convert_test.go.tmpl "--data={ \"pkg\": \"otelslog\" }" --out=convert_test.go
diff --git a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/handler.go b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/handler.go
index a8b86930a..ab95c2628 100644
--- a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/handler.go
+++ b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/handler.go
@@ -10,7 +10,7 @@
// way:
//
// - Time is set as the Timestamp.
-// - Message is set as the Body using a [log.StringValue].
+// - Message is set as the Body using an [attribute.StringValue].
// - Level is transformed and set as the Severity. The SeverityText is also
// set.
// - PC is dropped.
@@ -28,21 +28,21 @@
//
// - [slog.KindAny] values are transformed based on their type or
// into a string value encoded using [fmt.Sprintf] if there is no matching type.
-// - [slog.KindBool] are transformed to [log.BoolValue] directly.
-// - [slog.KindDuration] are transformed to [log.Int64Value] as nanoseconds.
-// - [slog.KindFloat64] are transformed to [log.Float64Value] directly.
-// - [slog.KindInt64] are transformed to [log.Int64Value] directly.
-// - [slog.KindString] are transformed to [log.StringValue] directly.
-// - [slog.KindTime] are transformed to [log.Int64Value] as nanoseconds since
+// - [slog.KindBool] are transformed to [attribute.BoolValue] directly.
+// - [slog.KindDuration] are transformed to [attribute.Int64Value] as nanoseconds.
+// - [slog.KindFloat64] are transformed to [attribute.Float64Value] directly.
+// - [slog.KindInt64] are transformed to [attribute.Int64Value] directly.
+// - [slog.KindString] are transformed to [attribute.StringValue] directly.
+// - [slog.KindTime] are transformed to [attribute.Int64Value] as nanoseconds since
// the Unix epoch.
-// - [slog.KindUint64] are transformed to [log.Int64Value] using int64
-// conversion.
-// - [slog.KindGroup] are transformed to [log.MapValue] using appropriate
+// - [slog.KindUint64] are transformed to [attribute.Int64Value] when they fit
+// in int64, otherwise to [attribute.Float64Value].
+// - [slog.KindGroup] are transformed to [attribute.MapValue] using appropriate
// transforms for each group value.
// - [slog.KindLogValuer] the value is resolved and then transformed.
//
// [OpenTelemetry]: https://opentelemetry.io/docs/concepts/signals/logs/
-package otelslog // import "go.opentelemetry.io/contrib/bridges/otelslog"
+package otelslog
import (
"context"
@@ -54,7 +54,7 @@ import (
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/log"
"go.opentelemetry.io/otel/log/global"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
// NewLogger returns a new [slog.Logger] backed by a new [Handler]. See
@@ -198,7 +198,7 @@ func (h *Handler) Handle(ctx context.Context, record slog.Record) error {
func (h *Handler) convertRecord(r slog.Record) log.Record {
var record log.Record
record.SetTimestamp(r.Time)
- record.SetBody(log.StringValue(r.Message))
+ record.SetBody(attribute.StringValue(r.Message))
const sevOffset = slog.Level(log.SeverityDebug) - slog.LevelDebug
record.SetSeverity(log.Severity(r.Level + sevOffset))
@@ -208,9 +208,9 @@ func (h *Handler) convertRecord(r slog.Record) log.Record {
fs := runtime.CallersFrames([]uintptr{r.PC})
f, _ := fs.Next()
record.AddAttributes(
- log.String(string(semconv.CodeFilePathKey), f.File),
- log.String(string(semconv.CodeFunctionNameKey), f.Function),
- log.Int(string(semconv.CodeLineNumberKey), f.Line),
+ attribute.String(string(semconv.CodeFilePathKey), f.File),
+ attribute.String(string(semconv.CodeFunctionNameKey), f.Function),
+ attribute.Int(string(semconv.CodeLineNumberKey), f.Line),
)
}
@@ -368,8 +368,8 @@ func (g *group) NextNonEmpty() *group {
return g.next.NextNonEmpty()
}
-// KeyValue returns group g containing kvs as a [log.KeyValue]. The value of
-// the returned KeyValue will be of type [log.KindMap].
+// KeyValue returns group g containing kvs as an [attribute.KeyValue]. The value of
+// the returned KeyValue will be of type [attribute.MAP].
//
// The passed kvs are rendered in the returned value, but are not added to the
// group.
@@ -377,14 +377,14 @@ func (g *group) NextNonEmpty() *group {
// This does not check g. It is the callers responsibility to ensure g is
// non-empty or kvs is non-empty so as to return a valid group representation
// (according to slog).
-func (g *group) KeyValue(kvs ...log.KeyValue) log.KeyValue {
+func (g *group) KeyValue(kvs ...attribute.KeyValue) attribute.KeyValue {
// Assumes checking of group g already performed (i.e. non-empty).
- out := log.Map(g.name, g.attrs.KeyValues(kvs...)...)
+ out := attribute.Map(g.name, g.attrs.KeyValues(kvs...)...)
g = g.next
for g != nil {
// A Handler should not output groups if there are no attributes.
if g.attrs.Len() > 0 {
- out = log.Map(g.name, g.attrs.KeyValues(out)...)
+ out = attribute.Map(g.name, g.attrs.KeyValues(out)...)
}
g = g.next
}
@@ -410,15 +410,21 @@ func (g *group) AddAttrs(attrs []slog.Attr) {
}
type kvBuffer struct {
- data []log.KeyValue
+ data []attribute.KeyValue
err error
+ // keepErr, when true, keeps an error-valued attribute as a normal
+ // attribute instead of promoting it to err. It is set when converting a
+ // group value, because a group maps to an attribute.MAP that has no
+ // dedicated error slot like a record does, so a promoted error would be
+ // silently dropped.
+ keepErr bool
}
func newKVBuffer(n int) *kvBuffer {
- return &kvBuffer{data: make([]log.KeyValue, 0, n)}
+ return &kvBuffer{data: make([]attribute.KeyValue, 0, n)}
}
-// Len returns the number of [log.KeyValue] held by b.
+// Len returns the number of [attribute.KeyValue] held by b.
func (b *kvBuffer) Len() int {
if b == nil {
return 0
@@ -431,15 +437,21 @@ func (b *kvBuffer) Clone() *kvBuffer {
if b == nil {
return nil
}
- return &kvBuffer{data: slices.Clone(b.data), err: b.err}
+ return &kvBuffer{data: slices.Clone(b.data), err: b.err, keepErr: b.keepErr}
}
-// KeyValues returns kvs appended to the [log.KeyValue] held by b.
-func (b *kvBuffer) KeyValues(kvs ...log.KeyValue) []log.KeyValue {
+// KeyValues returns kvs appended to the [attribute.KeyValue] held by b. The
+// returned slice never shares spare capacity with b's backing array, so
+// appending to it (including a concurrent KeyValues call on the same shared
+// buffer) cannot corrupt b or a slice returned by a previous call.
+func (b *kvBuffer) KeyValues(kvs ...attribute.KeyValue) []attribute.KeyValue {
if b == nil {
return kvs
}
- return append(b.data, kvs...)
+ // Clip forces append to allocate a new backing array rather than writing
+ // kvs into b.data's spare capacity, which is shared across concurrent
+ // Handle calls.
+ return append(slices.Clip(b.data), kvs...)
}
// AddAttrs adds attrs to b.
@@ -459,7 +471,7 @@ func (b *kvBuffer) AddAttrs(attrs []slog.Attr) {
//
// If attr is empty, it will be dropped.
func (b *kvBuffer) AddAttr(attr slog.Attr) bool {
- if attr.Value.Kind() == slog.KindAny {
+ if !b.keepErr && attr.Value.Kind() == slog.KindAny {
if err, ok := attr.Value.Any().(error); ok {
b.err = err
return true
@@ -480,41 +492,42 @@ func (b *kvBuffer) AddAttr(attr slog.Attr) bool {
return true
}
}
- b.data = append(b.data, log.KeyValue{
- Key: attr.Key,
+ b.data = append(b.data, attribute.KeyValue{
+ Key: attribute.Key(attr.Key),
Value: convert(attr.Value),
})
return true
}
-func convert(v slog.Value) log.Value {
+func convert(v slog.Value) attribute.Value {
switch v.Kind() {
case slog.KindAny:
return convertValue(v.Any())
case slog.KindBool:
- return log.BoolValue(v.Bool())
+ return attribute.BoolValue(v.Bool())
case slog.KindDuration:
- return log.Int64Value(v.Duration().Nanoseconds())
+ return attribute.Int64Value(v.Duration().Nanoseconds())
case slog.KindFloat64:
- return log.Float64Value(v.Float64())
+ return attribute.Float64Value(v.Float64())
case slog.KindInt64:
- return log.Int64Value(v.Int64())
+ return attribute.Int64Value(v.Int64())
case slog.KindString:
- return log.StringValue(v.String())
+ return attribute.StringValue(v.String())
case slog.KindTime:
- return log.Int64Value(v.Time().UnixNano())
+ return attribute.Int64Value(v.Time().UnixNano())
case slog.KindUint64:
const maxInt64 = ^uint64(0) >> 1
u := v.Uint64()
if u > maxInt64 {
- return log.Float64Value(float64(u))
+ return attribute.Float64Value(float64(u))
}
- return log.Int64Value(int64(u))
+ return attribute.Int64Value(int64(u))
case slog.KindGroup:
g := v.Group()
buf := newKVBuffer(len(g))
+ buf.keepErr = true
buf.AddAttrs(g)
- return log.MapValue(buf.data...)
+ return attribute.MapValue(buf.data...)
case slog.KindLogValuer:
return convert(v.Resolve())
default:
@@ -525,6 +538,6 @@ func convert(v slog.Value) log.Value {
// this malformed attribute as well as a panic. However, it is
// preferable to have user's open issue asking why their attributes
// have a "unhandled: " prefix than say that their code is panicking.
- return log.StringValue(fmt.Sprintf("unhandled: (%s) %+v", v.Kind(), v.Any()))
+ return attribute.StringValue(fmt.Sprintf("unhandled: (%s) %+v", v.Kind(), v.Any()))
}
}
diff --git a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/version.go b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/version.go
index c818de902..627f0b766 100644
--- a/vendor/go.opentelemetry.io/contrib/bridges/otelslog/version.go
+++ b/vendor/go.opentelemetry.io/contrib/bridges/otelslog/version.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otelslog // import "go.opentelemetry.io/contrib/bridges/otelslog"
+package otelslog
// Version is the current release version of the otelslog bridge.
-const Version = "0.19.0"
+const Version = "0.20.0"
diff --git a/vendor/go.opentelemetry.io/otel/.golangci.yml b/vendor/go.opentelemetry.io/otel/.golangci.yml
index 645c7e6af..8a7f1ec5d 100644
--- a/vendor/go.opentelemetry.io/otel/.golangci.yml
+++ b/vendor/go.opentelemetry.io/otel/.golangci.yml
@@ -96,9 +96,9 @@ linters:
- "!**/exporters/zipkin/**"
deny:
- pkg: go.opentelemetry.io/otel/semconv
- desc: "Use go.opentelemetry.io/otel/semconv/v1.41.0 instead. If a newer semconv version has been released, update the depguard rule."
+ desc: "Use go.opentelemetry.io/otel/semconv/v1.43.0 instead. If a newer semconv version has been released, update the depguard rule."
allow:
- - go.opentelemetry.io/otel/semconv/v1.41.0
+ - go.opentelemetry.io/otel/semconv/v1.43.0
gocritic:
disabled-checks:
- appendAssign
diff --git a/vendor/go.opentelemetry.io/otel/.lycheeignore b/vendor/go.opentelemetry.io/otel/.lycheeignore
index 994b677df..df0d328bf 100644
--- a/vendor/go.opentelemetry.io/otel/.lycheeignore
+++ b/vendor/go.opentelemetry.io/otel/.lycheeignore
@@ -11,3 +11,17 @@ http://4.3.2.1:78/user/123
file:///home/runner/work/opentelemetry-go/opentelemetry-go/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/dns:/:4317
# URL works, but it has blocked link checkers.
https://dl.acm.org/doi/10.1145/198429.198435
+https://pkg.go.dev/google.golang.org/grpc.*internal/resolver
+https://golang.org/src/crypto/tls/generate_cert.go
+https://github.com/grpc/grpc/blob/.*/doc/naming.md
+https://github.com/open-telemetry/opentelemetry-specification/blob/.*
+# Fake domains used in otlp options_test.go tests
+https?://env\.endpoint.*
+https?://env\.metrics\.endpoint.*
+https?://env_metrics_endpoint.*
+https?://env\.traces\.endpoint.*
+https?://env_traces_endpoint.*
+https?://someendpoint.*
+https?://overrode\.by\.signal\.specific.*
+https?://overrode_by_signal_specific.*
+https?://proxy\.com.*
diff --git a/vendor/go.opentelemetry.io/otel/AGENTS.md b/vendor/go.opentelemetry.io/otel/AGENTS.md
index 26c0fc4dd..02db71528 100644
--- a/vendor/go.opentelemetry.io/otel/AGENTS.md
+++ b/vendor/go.opentelemetry.io/otel/AGENTS.md
@@ -47,6 +47,9 @@ For docs-only, test-only, or review-only tasks, still start with the required re
- Prefer examples over long code snippets in GoDoc when practical.
- Keep docs aligned with actual behavior. Do not leave stale comments, stale examples, or stale package documentation behind.
- For user-visible changes, update `CHANGELOG.md` under the appropriate `Added`, `Changed`, `Deprecated`, `Fixed`, or `Removed` section within `## [Unreleased]`.
+ - Always put the PR number at the end of the line (e.g., `(#1234)`), NOT the issue number.
+ - If the PR number is not yet known, omit it until the PR is created, then update the changelog entry before merging.
+ - Always use references to the go module that is updated (e.g., `go.opentelemetry.io/otel/sdk/metric`), instead of just the path (e.g., `sdk/metric`).
## Repository habits
diff --git a/vendor/go.opentelemetry.io/otel/CHANGELOG.md b/vendor/go.opentelemetry.io/otel/CHANGELOG.md
index 6a90451f5..2db588ea2 100644
--- a/vendor/go.opentelemetry.io/otel/CHANGELOG.md
+++ b/vendor/go.opentelemetry.io/otel/CHANGELOG.md
@@ -11,6 +11,75 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
+## [1.45.0/0.67.0/0.21.0/0.0.18] - 2026-08-03
+
+### Added
+
+- Add experimental observability metrics to `BatchProcessor` in `go.opentelemetry.io/otel/sdk/log`. (#7124)
+- Add the experimental `WithUnsafeAttributes` no-copy attribute option to `go.opentelemetry.io/otel/metric/x` for future performance improvements. This API is a work in progress. (#8251)
+- Add `Map` and `MapValue` functions for the new `MAP` attribute type in `go.opentelemetry.io/otel/attribute`. (#8445)
+- Support `MAP` attributes in `go.opentelemetry.io/otel/exporters/otlp/otlptrace`. (#8453)
+- Support `MAP` attributes in `go.opentelemetry.io/otel/exporters/otlp/otlplog`. (#8453)
+- Support `MAP` attributes in `go.opentelemetry.io/otel/exporters/otlp/otlpmetric`. (#8453)
+- Support `MAP` attributes in `go.opentelemetry.io/otel/exporters/zipkin`. (#8453)
+- Apply `AttributeValueLengthLimit` recursively to values contained in `attribute.MAP` attributes in `go.opentelemetry.io/otel/sdk/trace`. (#8454)
+- Remove duplicate keys from `attribute.MAP` values in `go.opentelemetry.io/otel/sdk/resource` using last-value-wins semantics. (#8471)
+- Remove duplicate keys by default from `attribute.MAP` values in instrumentation scope attributes in `go.opentelemetry.io/otel/sdk/log` using last-value-wins semantics. (#8471)
+- Remove duplicate keys by default from `attribute.MAP` values in span, event, link, and instrumentation scope attributes in `go.opentelemetry.io/otel/sdk/trace` using last-value-wins semantics. (#8471)
+- Remove duplicate keys by default from `attribute.MAP` values in measurement and instrumentation scope attributes in `go.opentelemetry.io/otel/sdk/metric` using last-value-wins semantics. (#8471)
+- Extend `WithAllowKeyDuplication` in `go.opentelemetry.io/otel/sdk/log` to disable duplicate-key removal in `attribute.MAP` values for instrumentation scope attributes. (#8471)
+- Add the `go.opentelemetry.io/otel/semconv/v1.42.0` package.
+ The package contains semantic conventions from the `v1.42.0` version of the OpenTelemetry Semantic Conventions.
+ See the [migration documentation](./semconv/v1.42.0/MIGRATION.md) for information on how to upgrade from `go.opentelemetry.io/otel/semconv/v1.41.0`. (#8484)
+- Add `WithoutPanicRecording` as a `TracerProviderOption` in `go.opentelemetry.io/otel/sdk/trace` to disable exception event recording for panics. (#8532)
+- Add the `go.opentelemetry.io/otel/semconv/v1.43.0` package.
+ The package contains semantic conventions from the `v1.43.0` version of the OpenTelemetry Semantic Conventions.
+ See the [migration documentation](./semconv/v1.43.0/MIGRATION.md) for information on how to upgrade from `go.opentelemetry.io/otel/semconv/v1.42.0`. (#8628)
+
+### Changed
+
+- `HistogramReservoir` in `go.opentelemetry.io/otel/sdk/metric/exemplar` now uses a time-unbiased sampling algorithm for exemplars. (#8306)
+- ⚠️ **Breaking Change:** Use `go.opentelemetry.io/otel/attribute.Value` and `go.opentelemetry.io/otel/attribute.KeyValue` for log bodies and attributes in `go.opentelemetry.io/otel/log`, `go.opentelemetry.io/otel/log/logtest`, `go.opentelemetry.io/otel/sdk/log`, and `go.opentelemetry.io/otel/sdk/log/logtest`. (#8490)
+- Encode log bodies and attributes as `go.opentelemetry.io/otel/attribute.Value` JSON in `go.opentelemetry.io/otel/exporters/stdout/stdoutlog`. (#8490)
+- Improve the performance of hashing `BOOLSLICE`, `INT64SLICE`, `FLOAT64SLICE`, and `STRINGSLICE` attribute values by avoiding reflection for short slices in `go.opentelemetry.io/otel/attribute`. (#8511)
+- ⚠️ **Breaking Change:** `WithEndpointURL` in `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp` no longer appends the default signal path when an endpoint URL has no path, making the behavior consistent with `go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp` and with setting the endpoint through `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT`. If the URL has no path component, the root path (`/`) is used. Use `WithEndpointURL(url.JoinPath(endpoint, "/v1/metrics"))` to preserve the previous behavior. (#8538)
+- ⚠️ **Breaking Change:** `WithEndpointURL` in `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp` no longer appends the default signal path when an endpoint URL has no path, making the behavior consistent with `go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp` and with setting the endpoint through `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. If the URL has no path component, the root path (`/`) is used. Use `WithEndpointURL(url.JoinPath(endpoint, "/v1/traces"))` to preserve the previous behavior. (#8538)
+
+### Deprecated
+
+- Deprecate `WithExportBufferSize` in `go.opentelemetry.io/otel/sdk/log`. The option remains available for source compatibility but no longer affects behavior; `BatchProcessor` no longer maintains a separate export-request buffer. (#8620)
+
+### Removed
+
+- ⚠️ **Breaking Change:** Remove `Kind`, `Value`, `KeyValue`, their constructors, and attribute conversion helpers from `go.opentelemetry.io/otel/log`. (#8490)
+- ⚠️ **Breaking Change:** Remove the `AttributeValueLengthLimit` and `AttributeCountLimit` fields from `RecordFactory` in `go.opentelemetry.io/otel/sdk/log/logtest`; records produced by the factory now keep attribute limits disabled so test code can append exact attributes. (#8556)
+
+### Fixed
+
+- Apply TLS certificates configured through environment variables to gRPC connections in `go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc`.
+- Prevent panics in `go.opentelemetry.io/otel/bridge/opentracing` when OpenTracing baggage is propagated concurrently with `Span.SetBaggageItem`.
+- Fix an off-by-one error in `FixedSizeReservoir` in `go.opentelemetry.io/otel/sdk/metric/exemplar` that prevented the first exemplar from being sampled after the reservoir was filled. (#8309)
+- Interpret HTTP `Retry-After` header values as seconds instead of nanoseconds when retrying OTLP HTTP exports in `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp`, `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp`, and `go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp`. (#8383)
+- Fix a memory leak in the `Reservoir` implementation in `go.opentelemetry.io/otel/sdk/metric/exemplar`, where storing the full `context.Context` pinned large objects such as gRPC transport buffers. (#8389)
+- Prevent a non-empty attribute set whose computed hash is zero from collapsing to an empty set in `go.opentelemetry.io/otel/attribute`. (#8402)
+- Fix histogram data point reuse in `go.opentelemetry.io/otel/sdk/metric` aggregation to avoid leaking stale sum, minimum, and maximum values when they are disabled in subsequent collections. (#8403)
+- Avoid preallocating scope attributes when they are disabled in `go.opentelemetry.io/otel/exporters/prometheus`. (#8404)
+- Support HTTP-date values in the HTTP `Retry-After` header when retrying OTLP HTTP exports in `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp`, `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp`, and `go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp`. (#8417)
+- Reduce histogram heap allocations by reusing `BucketCounts` and `Exemplars` slices across `Collect` cycles in the cumulative histogram aggregation in `go.opentelemetry.io/otel/sdk/metric`. (#8428)
+- Fix `go.opentelemetry.io/otel/exporters/stdout/stdouttrace` self-observability to record `error.type` on the operation-duration histogram when the `exportedSpans` metric is disabled. (#8432)
+- Stop including trace exporter endpoint configuration in internal logs from `go.opentelemetry.io/otel/sdk/trace`, `go.opentelemetry.io/otel/exporters/otlp/otlptrace`, `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc`, `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp`, and `go.opentelemetry.io/otel/exporters/zipkin`. (#8438)
+- Fix invalid error formatting for out-of-range JSON code values in `go.opentelemetry.io/otel/codes`. (#8497)
+- Clarify in `go.opentelemetry.io/otel/log` that `Logger.Enabled` should be checked for every log emission because its result may change over time. (#8565)
+- Preserve user-provided exception attributes while independently deriving missing exception message and type attributes in `go.opentelemetry.io/otel/sdk/log`. (#8566)
+- Make `WithAttributeCountLimit(0)` and `OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT=0` discard all log record attributes in `go.opentelemetry.io/otel/sdk/log`. (#8570)
+- Clarify that the `Record` methods of `Float64Histogram` and `Int64Histogram` in `go.opentelemetry.io/otel/metric` expect non-negative values. (#8574)
+- Clarify in `go.opentelemetry.io/otel/log` that `LoggerProvider` implementations should retain an empty `Logger` name instead of replacing it with a default. (#8587)
+- Ensure that the built-in processors in `go.opentelemetry.io/otel/sdk/log` call exporter `ForceFlush` during `Shutdown`. (#8599)
+- Prevent processor operations in `go.opentelemetry.io/otel/sdk/log` from overlapping with processor shutdown or running after `LoggerProvider` shutdown. (#8608)
+- Prevent `BatchProcessor` in `go.opentelemetry.io/otel/sdk/log` from busy-spinning under exporter backpressure and serialize dequeue, export, force-flush, and shutdown work in one worker. (#8620)
+- Make `BatchProcessor` in `go.opentelemetry.io/otel/sdk/log` return errors encountered while draining records during `ForceFlush` and `Shutdown`, while continuing to attempt later batches as long as the request context remains valid. (#8620)
+- Keep the default `BatchProcessor` maximum export batch size in `go.opentelemetry.io/otel/sdk/log` at or below the configured maximum queue size. (#8620)
+
## [1.44.0/0.66.0/0.20.0/0.0.17] 2026-05-27
### Added
@@ -42,13 +111,13 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
Set `OTEL_GO_X_METRIC_EXPORT_BATCH_SIZE=` to enable for all periodic readers.
See `go.opentelemetry.io/otel/sdk/metric/internal/x` for feature documentation. (#8071)
- Add experimental self-observability metrics in `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc`.
- Enable with `OTEL_GO_X_SELF_OBSERVABILITY=true` environment variable.
+ Enable with `OTEL_GO_X_OBSERVABILITY=true` environment variable.
See `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc/internal/x` for feature documentation. (#8192)
- Add experimental self-observability metrics in `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp`.
- Enable with `OTEL_GO_X_SELF_OBSERVABILITY=true` environment variable.
+ Enable with `OTEL_GO_X_OBSERVABILITY=true` environment variable.
See `go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp/internal/x` for feature documentation. (#8194)
- Add experimental self-observability metrics in `go.opentelemetry.io/otel/exporters/stdout/stdoutlog`.
- Enable with `OTEL_GO_X_SELF_OBSERVABILITY=true` environment variable.
+ Enable with `OTEL_GO_X_OBSERVABILITY=true` environment variable.
See `go.opentelemetry.io/otel/stdout/stdoutlog/internal/x` for feature documentation. (#8263)
- Add `WithDefaultAttributes` to `go.opentelemetry.io/otel/metric/x` to support setting default attributes on instruments. (#8135)
- Add `go.opentelemetry.io/otel/semconv/v1.41.0` package.
@@ -3713,7 +3782,8 @@ It contains api and sdk for trace and meter.
- CircleCI build CI manifest files.
- CODEOWNERS file to track owners of this project.
-[Unreleased]: https://github.com/open-telemetry/opentelemetry-go/compare/v1.44.0...HEAD
+[Unreleased]: https://github.com/open-telemetry/opentelemetry-go/compare/v1.45.0...HEAD
+[1.45.0/0.67.0/0.21.0/0.0.18]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.45.0
[1.44.0/0.66.0/0.20.0/0.0.17]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.44.0
[1.43.0/0.65.0/0.19.0]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.43.0
[1.42.0/0.64.0/0.18.0/0.0.16]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.42.0
diff --git a/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md b/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md
index 3ec17d683..2aba71e19 100644
--- a/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md
+++ b/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md
@@ -8,8 +8,10 @@ repo for information on this and other language SIGs.
See the [public meeting
notes](https://docs.google.com/document/d/1E5e7Ld0NuU1iVvf-42tOBpu2VBBLYnh73GJuITGJTTU/edit)
for a summary description of past meetings. To request edit access,
-join the meeting or get in touch on
-[Slack](https://cloud-native.slack.com/archives/C01NPAXACKT).
+join the meeting or get in touch on the
+[#otel-go](https://cloud-native.slack.com/archives/C01NPAXACKT)
+channel on CNCF Slack. If you are new to the CNCF Slack community,
+you can [create an account](https://slack.cncf.io/).
The meeting is open for all to join. We invite everyone to join our
meeting, regardless of your experience level. Whether you're a
@@ -752,8 +754,8 @@ Encapsulate setup in constructor functions, ensuring clear ownership and scope:
import (
"errors"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
type SDKComponent struct {
@@ -1054,7 +1056,7 @@ func (e *Exporter) ExportSpans(ctx context.Context, spans []trace.ReadOnlySpan)
All observability metrics should follow the [OpenTelemetry Semantic Conventions for SDK metrics](https://github.com/open-telemetry/semantic-conventions/blob/1cf2476ae5e518225a766990a28a6d5602bd5a30/docs/otel/sdk-metrics.md).
-Use the metric semantic conventions convenience package [otelconv](./semconv/v1.41.0/otelconv/metric.go).
+Use the metric semantic conventions convenience package [otelconv](./semconv/v1.43.0/otelconv/metric.go).
##### Component Identification
diff --git a/vendor/go.opentelemetry.io/otel/Makefile b/vendor/go.opentelemetry.io/otel/Makefile
index de63a5e9b..d4711257d 100644
--- a/vendor/go.opentelemetry.io/otel/Makefile
+++ b/vendor/go.opentelemetry.io/otel/Makefile
@@ -10,6 +10,7 @@ ALL_COVERAGE_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {}
GO = go
TIMEOUT = 60
+GO_VERSION := $(shell awk '/^go [0-9]/ {print $$2; exit}' go.mod)
# User to run as in docker images.
DOCKER_USER=$(shell id -u):$(shell id -g)
@@ -19,7 +20,7 @@ DEPENDENCIES_DOCKERFILE=./dependencies.Dockerfile
.PHONY: precommit ci
precommit: generate toolchain-check license-check misspell go-mod-tidy golangci-lint-fix verify-readmes verify-mods test-default
-ci: generate toolchain-check license-check lint vanity-import-check verify-readmes verify-mods build test-default check-clean-work-tree test-coverage
+ci: generate toolchain-check license-check lint verify-readmes verify-mods build test-default check-clean-work-tree test-coverage
# Tools
@@ -59,9 +60,6 @@ $(TOOLS)/gocovmerge: PACKAGE=github.com/wadey/gocovmerge
STRINGER = $(TOOLS)/stringer
$(TOOLS)/stringer: PACKAGE=golang.org/x/tools/cmd/stringer
-PORTO = $(TOOLS)/porto
-$(TOOLS)/porto: PACKAGE=github.com/jcchavezs/porto/cmd/porto
-
GOTMPL = $(TOOLS)/gotmpl
$(GOTMPL): PACKAGE=go.opentelemetry.io/build-tools/gotmpl
@@ -72,7 +70,7 @@ GOVULNCHECK = $(TOOLS)/govulncheck
$(TOOLS)/govulncheck: PACKAGE=golang.org/x/vuln/cmd/govulncheck
.PHONY: tools
-tools: $(CROSSLINK) $(GOLANGCI_LINT) $(MISSPELL) $(GOCOVMERGE) $(STRINGER) $(PORTO) $(VERIFYREADMES) $(MULTIMOD) $(SEMCONVKIT) $(GOTMPL) $(GORELEASE)
+tools: $(CROSSLINK) $(GOLANGCI_LINT) $(MISSPELL) $(GOCOVMERGE) $(STRINGER) $(VERIFYREADMES) $(MULTIMOD) $(SEMCONVKIT) $(GOTMPL) $(GORELEASE)
# Virtualized python tools via docker
@@ -110,7 +108,7 @@ $(CODESPELL): PACKAGE=codespell
# Generate
.PHONY: generate
-generate: go-generate vanity-import-fix
+generate: go-generate
.PHONY: go-generate
go-generate: $(OTEL_GO_MOD_DIRS:%=go-generate/%)
@@ -120,14 +118,10 @@ go-generate/%: $(STRINGER) $(GOTMPL)
&& cd $(DIR) \
&& PATH="$(TOOLS):$${PATH}" $(GO) generate ./...
-.PHONY: vanity-import-fix
-vanity-import-fix: $(PORTO)
- @$(PORTO) --include-internal -w .
-
# Generate go.work file for local development.
.PHONY: go-work
go-work: $(CROSSLINK)
- $(CROSSLINK) work --root=$(shell pwd) --go=1.22.7
+ $(CROSSLINK) work --root=$(shell pwd) --go=$(GO_VERSION)
# Build
@@ -228,10 +222,6 @@ go-mod-tidy/%: crosslink
.PHONY: lint
lint: misspell go-mod-tidy golangci-lint
-.PHONY: vanity-import-check
-vanity-import-check: $(PORTO)
- @$(PORTO) --include-internal -l . || ( echo "(run: make vanity-import-fix)"; exit 1 )
-
.PHONY: misspell
misspell: $(MISSPELL)
@$(MISSPELL) -w $(ALL_DOCS)
diff --git a/vendor/go.opentelemetry.io/otel/README.md b/vendor/go.opentelemetry.io/otel/README.md
index 16a72004c..ce97e9a25 100644
--- a/vendor/go.opentelemetry.io/otel/README.md
+++ b/vendor/go.opentelemetry.io/otel/README.md
@@ -113,3 +113,10 @@ All officially supported exporters for the OpenTelemetry project are contained i
## Contributing
See the [contributing documentation](CONTRIBUTING.md).
+
+### Emeritus
+
+- [Alex Kats](https://github.com/akats7), Triager
+
+For more information about the emeritus role, see the
+[community repository](https://github.com/open-telemetry/community/blob/main/guides/contributor/membership.md#emeritus-maintainerapprovertriager).
diff --git a/vendor/go.opentelemetry.io/otel/attribute/doc.go b/vendor/go.opentelemetry.io/otel/attribute/doc.go
index eef51ebc2..c543f2ca6 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/doc.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/doc.go
@@ -2,4 +2,4 @@
// SPDX-License-Identifier: Apache-2.0
// Package attribute provides key and value attributes.
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
diff --git a/vendor/go.opentelemetry.io/otel/attribute/encoder.go b/vendor/go.opentelemetry.io/otel/attribute/encoder.go
index ca186d8ac..413e7a185 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/encoder.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/encoder.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
import (
"bytes"
diff --git a/vendor/go.opentelemetry.io/otel/attribute/filter.go b/vendor/go.opentelemetry.io/otel/attribute/filter.go
index 624ebbe38..6dab64f5d 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/filter.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/filter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
// Filter supports removing certain attributes from attribute sets. When
// the filter returns true, the attribute will be kept in the filtered
diff --git a/vendor/go.opentelemetry.io/otel/attribute/hash.go b/vendor/go.opentelemetry.io/otel/attribute/hash.go
index 92f39ffe7..f651eb13d 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/hash.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/hash.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
import (
"fmt"
@@ -29,6 +29,7 @@ const (
stringSliceID uint64 = 7453010373645655387 // "[]string" (little endian)
byteSliceID uint64 = 6874028470941080415 // "_[]byte_" (little endian)
sliceID uint64 = 7883494272577650031 // "__slice_" (little endian)
+ mapID uint64 = 6872316492666199903 // "__map___" (little endian)
emptyID uint64 = 7305809155345288421 // "__empty_" (little endian)
)
@@ -38,7 +39,13 @@ func hashKVs(kvs []KeyValue) uint64 {
for _, kv := range kvs {
h = hashKV(h, kv)
}
- return h.Sum64()
+ sum := h.Sum64()
+ // Remap 0 to a non-zero value for non-empty input because hash == 0 is a reserved sentinel (treated as empty/invalid).
+ const remappedZeroHash uint64 = 1
+ if sum == 0 && len(kvs) > 0 {
+ return remappedZeroHash
+ }
+ return sum
}
// hashKV returns the xxHash64 hash of kv with h as the base.
@@ -64,27 +71,79 @@ func hashValue(h xxhash.Hash, v Value) xxhash.Hash {
h = h.String(v.stringly)
case BOOLSLICE:
h = h.Uint64(boolSliceID)
- rv := reflect.ValueOf(v.slice)
- for i := 0; i < rv.Len(); i++ {
- h = h.Bool(rv.Index(i).Bool())
+ switch vals := v.slice.(type) {
+ case [0]bool:
+ case [1]bool:
+ h = h.Bool(vals[0])
+ case [2]bool:
+ h = h.Bool(vals[0])
+ h = h.Bool(vals[1])
+ case [3]bool:
+ h = h.Bool(vals[0])
+ h = h.Bool(vals[1])
+ h = h.Bool(vals[2])
+ default:
+ rv := reflect.ValueOf(v.slice)
+ for i := 0; i < rv.Len(); i++ {
+ h = h.Bool(rv.Index(i).Bool())
+ }
}
case INT64SLICE:
h = h.Uint64(int64SliceID)
- rv := reflect.ValueOf(v.slice)
- for i := 0; i < rv.Len(); i++ {
- h = h.Int64(rv.Index(i).Int())
+ switch vals := v.slice.(type) {
+ case [0]int64:
+ case [1]int64:
+ h = h.Int64(vals[0])
+ case [2]int64:
+ h = h.Int64(vals[0])
+ h = h.Int64(vals[1])
+ case [3]int64:
+ h = h.Int64(vals[0])
+ h = h.Int64(vals[1])
+ h = h.Int64(vals[2])
+ default:
+ rv := reflect.ValueOf(v.slice)
+ for i := 0; i < rv.Len(); i++ {
+ h = h.Int64(rv.Index(i).Int())
+ }
}
case FLOAT64SLICE:
h = h.Uint64(float64SliceID)
- rv := reflect.ValueOf(v.slice)
- for i := 0; i < rv.Len(); i++ {
- h = h.Float64(rv.Index(i).Float())
+ switch vals := v.slice.(type) {
+ case [0]float64:
+ case [1]float64:
+ h = h.Float64(vals[0])
+ case [2]float64:
+ h = h.Float64(vals[0])
+ h = h.Float64(vals[1])
+ case [3]float64:
+ h = h.Float64(vals[0])
+ h = h.Float64(vals[1])
+ h = h.Float64(vals[2])
+ default:
+ rv := reflect.ValueOf(v.slice)
+ for i := 0; i < rv.Len(); i++ {
+ h = h.Float64(rv.Index(i).Float())
+ }
}
case STRINGSLICE:
h = h.Uint64(stringSliceID)
- rv := reflect.ValueOf(v.slice)
- for i := 0; i < rv.Len(); i++ {
- h = h.String(rv.Index(i).String())
+ switch vals := v.slice.(type) {
+ case [0]string:
+ case [1]string:
+ h = h.String(vals[0])
+ case [2]string:
+ h = h.String(vals[0])
+ h = h.String(vals[1])
+ case [3]string:
+ h = h.String(vals[0])
+ h = h.String(vals[1])
+ h = h.String(vals[2])
+ default:
+ rv := reflect.ValueOf(v.slice)
+ for i := 0; i < rv.Len(); i++ {
+ h = h.String(rv.Index(i).String())
+ }
}
case BYTESLICE:
h = h.Uint64(byteSliceID)
@@ -95,21 +154,79 @@ func hashValue(h xxhash.Hash, v Value) xxhash.Hash {
case [0]Value:
// No values to hash, but the type identifier is still hashed above.
case [1]Value:
- h = hashValueSlice(h, vals[:])
+ h = hashValue(h, vals[0])
case [2]Value:
- h = hashValueSlice(h, vals[:])
+ h = hashValue(h, vals[0])
+ h = hashValue(h, vals[1])
case [3]Value:
- h = hashValueSlice(h, vals[:])
+ h = hashValue(h, vals[0])
+ h = hashValue(h, vals[1])
+ h = hashValue(h, vals[2])
case [4]Value:
- h = hashValueSlice(h, vals[:])
+ h = hashValue(h, vals[0])
+ h = hashValue(h, vals[1])
+ h = hashValue(h, vals[2])
+ h = hashValue(h, vals[3])
case [5]Value:
- h = hashValueSlice(h, vals[:])
+ h = hashValue(h, vals[0])
+ h = hashValue(h, vals[1])
+ h = hashValue(h, vals[2])
+ h = hashValue(h, vals[3])
+ h = hashValue(h, vals[4])
default:
rv := reflect.ValueOf(v.slice)
for i := 0; i < rv.Len(); i++ {
h = hashValue(h, rv.Index(i).Interface().(Value))
}
}
+ case MAP:
+ h = h.Uint64(mapID)
+ switch vals := v.slice.(type) {
+ case [0]KeyValue:
+ // No values to hash, but the type identifier is still hashed above.
+ case [1]KeyValue:
+ h = h.String(string(vals[0].Key))
+ h = hashValue(h, vals[0].Value)
+ case [2]KeyValue:
+ h = h.String(string(vals[0].Key))
+ h = hashValue(h, vals[0].Value)
+ h = h.String(string(vals[1].Key))
+ h = hashValue(h, vals[1].Value)
+ case [3]KeyValue:
+ h = h.String(string(vals[0].Key))
+ h = hashValue(h, vals[0].Value)
+ h = h.String(string(vals[1].Key))
+ h = hashValue(h, vals[1].Value)
+ h = h.String(string(vals[2].Key))
+ h = hashValue(h, vals[2].Value)
+ case [4]KeyValue:
+ h = h.String(string(vals[0].Key))
+ h = hashValue(h, vals[0].Value)
+ h = h.String(string(vals[1].Key))
+ h = hashValue(h, vals[1].Value)
+ h = h.String(string(vals[2].Key))
+ h = hashValue(h, vals[2].Value)
+ h = h.String(string(vals[3].Key))
+ h = hashValue(h, vals[3].Value)
+ case [5]KeyValue:
+ h = h.String(string(vals[0].Key))
+ h = hashValue(h, vals[0].Value)
+ h = h.String(string(vals[1].Key))
+ h = hashValue(h, vals[1].Value)
+ h = h.String(string(vals[2].Key))
+ h = hashValue(h, vals[2].Value)
+ h = h.String(string(vals[3].Key))
+ h = hashValue(h, vals[3].Value)
+ h = h.String(string(vals[4].Key))
+ h = hashValue(h, vals[4].Value)
+ default:
+ rv := reflect.ValueOf(v.slice)
+ for i := 0; i < rv.Len(); i++ {
+ kv := rv.Index(i).Interface().(KeyValue)
+ h = h.String(string(kv.Key))
+ h = hashValue(h, kv.Value)
+ }
+ }
case EMPTY:
h = h.Uint64(emptyID)
default:
@@ -121,10 +238,3 @@ func hashValue(h xxhash.Hash, v Value) xxhash.Hash {
}
return h
}
-
-func hashValueSlice(h xxhash.Hash, vals []Value) xxhash.Hash {
- for _, v := range vals {
- h = hashValue(h, v)
- }
- return h
-}
diff --git a/vendor/go.opentelemetry.io/otel/attribute/internal/attribute.go b/vendor/go.opentelemetry.io/otel/attribute/internal/attribute.go
index d9f51fa2d..ec4a5f07f 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/internal/attribute.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/internal/attribute.go
@@ -5,7 +5,7 @@
Package attribute provide several helper functions for some commonly used
logic of processing attributes.
*/
-package attribute // import "go.opentelemetry.io/otel/attribute/internal"
+package attribute
import (
"reflect"
diff --git a/vendor/go.opentelemetry.io/otel/attribute/internal/xxhash/xxhash.go b/vendor/go.opentelemetry.io/otel/attribute/internal/xxhash/xxhash.go
index 113a97838..c851179cc 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/internal/xxhash/xxhash.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/internal/xxhash/xxhash.go
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// Package xxhash provides a wrapper around the xxhash library for attribute hashing.
-package xxhash // import "go.opentelemetry.io/otel/attribute/internal/xxhash"
+package xxhash
import (
"encoding/binary"
diff --git a/vendor/go.opentelemetry.io/otel/attribute/iterator.go b/vendor/go.opentelemetry.io/otel/attribute/iterator.go
index 8df6249f0..1afd00ff0 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/iterator.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/iterator.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
// Iterator allows iterating over the set of attributes in order, sorted by
// key.
diff --git a/vendor/go.opentelemetry.io/otel/attribute/key.go b/vendor/go.opentelemetry.io/otel/attribute/key.go
index cdc7089e8..6403191c2 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/key.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/key.go
@@ -1,16 +1,16 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
// Key represents the key part in key-value pairs. It's a string. The
// allowed character set in the key depends on the use of the key.
type Key string
-// Bool creates a KeyValue instance with a BOOL Value.
+// Bool returns a [KeyValue] for a bool value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Bool(name, value).
+// If creating both a key and value at the same time, use the package-level
+// [Bool] function.
func (k Key) Bool(v bool) KeyValue {
return KeyValue{
Key: k,
@@ -18,10 +18,15 @@ func (k Key) Bool(v bool) KeyValue {
}
}
-// BoolSlice creates a KeyValue instance with a BOOLSLICE Value.
+// BoolSlice returns a [KeyValue] for a []bool value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- BoolSlice(name, value).
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// If creating both a key and value at the same time, use the package-level
+// [BoolSlice] function.
func (k Key) BoolSlice(v []bool) KeyValue {
return KeyValue{
Key: k,
@@ -29,10 +34,12 @@ func (k Key) BoolSlice(v []bool) KeyValue {
}
}
-// Int creates a KeyValue instance with an INT64 Value.
+// Int returns a [KeyValue] for an int value.
+//
+// It is provided as a convenience for [Key.Int64].
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Int(name, value).
+// If creating both a key and value at the same time, use the package-level [Int]
+// function.
func (k Key) Int(v int) KeyValue {
return KeyValue{
Key: k,
@@ -40,10 +47,17 @@ func (k Key) Int(v int) KeyValue {
}
}
-// IntSlice creates a KeyValue instance with an INT64SLICE Value.
+// IntSlice returns a [KeyValue] for a []int value.
+//
+// It is provided as a convenience for [Key.Int64Slice].
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- IntSlice(name, value).
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// If creating both a key and value at the same time, use the package-level
+// [IntSlice] function.
func (k Key) IntSlice(v []int) KeyValue {
return KeyValue{
Key: k,
@@ -51,10 +65,10 @@ func (k Key) IntSlice(v []int) KeyValue {
}
}
-// Int64 creates a KeyValue instance with an INT64 Value.
+// Int64 returns a [KeyValue] for an int64 value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Int64(name, value).
+// If creating both a key and value at the same time, use the package-level
+// [Int64] function.
func (k Key) Int64(v int64) KeyValue {
return KeyValue{
Key: k,
@@ -62,10 +76,15 @@ func (k Key) Int64(v int64) KeyValue {
}
}
-// Int64Slice creates a KeyValue instance with an INT64SLICE Value.
+// Int64Slice returns a [KeyValue] for a []int64 value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Int64Slice(name, value).
+// If creating both a key and value at the same time, use the package-level
+// [Int64Slice] function.
func (k Key) Int64Slice(v []int64) KeyValue {
return KeyValue{
Key: k,
@@ -73,10 +92,10 @@ func (k Key) Int64Slice(v []int64) KeyValue {
}
}
-// Float64 creates a KeyValue instance with a FLOAT64 Value.
+// Float64 returns a [KeyValue] for a float64 value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Float64(name, value).
+// If creating both a key and value at the same time, use the package-level
+// [Float64] function.
func (k Key) Float64(v float64) KeyValue {
return KeyValue{
Key: k,
@@ -84,10 +103,15 @@ func (k Key) Float64(v float64) KeyValue {
}
}
-// Float64Slice creates a KeyValue instance with a FLOAT64SLICE Value.
+// Float64Slice returns a [KeyValue] for a []float64 value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Float64(name, value).
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// If creating both a key and value at the same time, use the package-level
+// [Float64Slice] function.
func (k Key) Float64Slice(v []float64) KeyValue {
return KeyValue{
Key: k,
@@ -95,10 +119,10 @@ func (k Key) Float64Slice(v []float64) KeyValue {
}
}
-// String creates a KeyValue instance with a STRING Value.
+// String returns a [KeyValue] for a string value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- String(name, value).
+// If creating both a key and value at the same time, use the package-level
+// [String] function.
func (k Key) String(v string) KeyValue {
return KeyValue{
Key: k,
@@ -106,10 +130,15 @@ func (k Key) String(v string) KeyValue {
}
}
-// StringSlice creates a KeyValue instance with a STRINGSLICE Value.
+// StringSlice returns a [KeyValue] for a []string value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- StringSlice(name, value).
+// If creating both a key and value at the same time, use the package-level
+// [StringSlice] function.
func (k Key) StringSlice(v []string) KeyValue {
return KeyValue{
Key: k,
@@ -117,10 +146,15 @@ func (k Key) StringSlice(v []string) KeyValue {
}
}
-// ByteSlice creates a KeyValue instance with a BYTESLICE Value.
+// ByteSlice returns a [KeyValue] for a []byte value.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- ByteSlice(name, value).
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// If creating both a key and value at the same time, use the package-level
+// [ByteSlice] function.
func (k Key) ByteSlice(v []byte) KeyValue {
return KeyValue{
Key: k,
@@ -128,10 +162,15 @@ func (k Key) ByteSlice(v []byte) KeyValue {
}
}
-// Slice creates a KeyValue instance with a SLICE Value.
+// Slice returns a [KeyValue] for a []Value value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
//
-// If creating both a key and value at the same time, use the provided
-// convenience function instead -- Slice(name, values...).
+// If creating both a key and value at the same time, use the package-level
+// [Slice] function.
func (k Key) Slice(v ...Value) KeyValue {
return KeyValue{
Key: k,
@@ -139,6 +178,27 @@ func (k Key) Slice(v ...Value) KeyValue {
}
}
+// Map returns a [KeyValue] for a []KeyValue value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// Users should avoid providing duplicate keys; many receivers handle maps
+// containing duplicate keys unpredictably.
+//
+// The order of v is not preserved.
+//
+// If creating both a key and value at the same time, use the package-level [Map]
+// function.
+func (k Key) Map(v ...KeyValue) KeyValue {
+ return KeyValue{
+ Key: k,
+ Value: MapValue(v...),
+ }
+}
+
// Defined reports whether the key is not empty.
func (k Key) Defined() bool {
return len(k) != 0
diff --git a/vendor/go.opentelemetry.io/otel/attribute/kv.go b/vendor/go.opentelemetry.io/otel/attribute/kv.go
index eeb76a134..c4f0dd928 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/kv.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/kv.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
import (
"fmt"
@@ -18,66 +18,120 @@ func (kv KeyValue) Valid() bool {
return kv.Key.Defined()
}
-// Bool creates a KeyValue with a BOOL Value type.
+// Bool returns a [KeyValue] for a bool value.
func Bool(k string, v bool) KeyValue {
return Key(k).Bool(v)
}
-// BoolSlice creates a KeyValue with a BOOLSLICE Value type.
+// BoolSlice returns a [KeyValue] for a []bool value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func BoolSlice(k string, v []bool) KeyValue {
return Key(k).BoolSlice(v)
}
-// Int creates a KeyValue with an INT64 Value type.
+// Int returns a [KeyValue] for an int value.
+//
+// It is provided as a convenience for [Int64].
func Int(k string, v int) KeyValue {
return Key(k).Int(v)
}
-// IntSlice creates a KeyValue with an INT64SLICE Value type.
+// IntSlice returns a [KeyValue] for a []int value.
+//
+// It is provided as a convenience for [Int64Slice].
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func IntSlice(k string, v []int) KeyValue {
return Key(k).IntSlice(v)
}
-// Int64 creates a KeyValue with an INT64 Value type.
+// Int64 returns a [KeyValue] for an int64 value.
func Int64(k string, v int64) KeyValue {
return Key(k).Int64(v)
}
-// Int64Slice creates a KeyValue with an INT64SLICE Value type.
+// Int64Slice returns a [KeyValue] for a []int64 value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func Int64Slice(k string, v []int64) KeyValue {
return Key(k).Int64Slice(v)
}
-// Float64 creates a KeyValue with a FLOAT64 Value type.
+// Float64 returns a [KeyValue] for a float64 value.
func Float64(k string, v float64) KeyValue {
return Key(k).Float64(v)
}
-// Float64Slice creates a KeyValue with a FLOAT64SLICE Value type.
+// Float64Slice returns a [KeyValue] for a []float64 value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func Float64Slice(k string, v []float64) KeyValue {
return Key(k).Float64Slice(v)
}
-// String creates a KeyValue with a STRING Value type.
+// String returns a [KeyValue] for a string value.
func String(k, v string) KeyValue {
return Key(k).String(v)
}
-// StringSlice creates a KeyValue with a STRINGSLICE Value type.
+// StringSlice returns a [KeyValue] for a []string value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func StringSlice(k string, v []string) KeyValue {
return Key(k).StringSlice(v)
}
-// ByteSlice creates a KeyValue with a BYTESLICE Value type.
+// ByteSlice returns a [KeyValue] for a []byte value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func ByteSlice(k string, v []byte) KeyValue {
return Key(k).ByteSlice(v)
}
-// Slice creates a KeyValue with a SLICE Value type.
+// Slice returns a [KeyValue] for a []Value value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func Slice(k string, v ...Value) KeyValue {
return Key(k).Slice(v...)
}
+// Map returns a [KeyValue] for a []KeyValue value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// Users should avoid providing duplicate keys; many receivers handle maps
+// containing duplicate keys unpredictably.
+//
+// The order of v is not preserved.
+func Map(k string, v ...KeyValue) KeyValue {
+ return Key(k).Map(v...)
+}
+
// Stringer creates a new key-value pair with a passed name and a string
// value generated by the passed Stringer interface.
func Stringer(k string, v fmt.Stringer) KeyValue {
diff --git a/vendor/go.opentelemetry.io/otel/attribute/rawhelpers.go b/vendor/go.opentelemetry.io/otel/attribute/rawhelpers.go
index 5791c6e7a..939e46f90 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/rawhelpers.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/rawhelpers.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
import (
"math"
diff --git a/vendor/go.opentelemetry.io/otel/attribute/set.go b/vendor/go.opentelemetry.io/otel/attribute/set.go
index a4b6ce81d..87d6f9620 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/set.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/set.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
import (
"cmp"
diff --git a/vendor/go.opentelemetry.io/otel/attribute/type_string.go b/vendor/go.opentelemetry.io/otel/attribute/type_string.go
index dbc01d324..ab5da2288 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/type_string.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/type_string.go
@@ -19,11 +19,12 @@ func _() {
_ = x[STRINGSLICE-8]
_ = x[BYTESLICE-9]
_ = x[SLICE-10]
+ _ = x[MAP-11]
}
-const _Type_name = "EMPTYBOOLINT64FLOAT64STRINGBOOLSLICEINT64SLICEFLOAT64SLICESTRINGSLICEBYTESLICESLICE"
+const _Type_name = "EMPTYBOOLINT64FLOAT64STRINGBOOLSLICEINT64SLICEFLOAT64SLICESTRINGSLICEBYTESLICESLICEMAP"
-var _Type_index = [...]uint8{0, 5, 9, 14, 21, 27, 36, 46, 58, 69, 78, 83}
+var _Type_index = [...]uint8{0, 5, 9, 14, 21, 27, 36, 46, 58, 69, 78, 83, 86}
func (i Type) String() string {
idx := int(i) - 0
diff --git a/vendor/go.opentelemetry.io/otel/attribute/value.go b/vendor/go.opentelemetry.io/otel/attribute/value.go
index 0529fefae..07a0353a1 100644
--- a/vendor/go.opentelemetry.io/otel/attribute/value.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/value.go
@@ -1,14 +1,16 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package attribute // import "go.opentelemetry.io/otel/attribute"
+package attribute
import (
+ "cmp"
"encoding/base64"
"encoding/json"
"fmt"
"math"
"reflect"
+ "slices"
"strconv"
"strings"
"unicode/utf8"
@@ -18,10 +20,10 @@ import (
//go:generate stringer -type=Type
-// Type describes the type of the data Value holds.
+// Type describes the kind of data a [Value] holds.
type Type int // nolint: revive // redefines builtin Type.
-// Value represents the value part in key-value pairs.
+// Value represents the value in key-value pairs.
//
// Note that the zero value is a valid empty value.
type Value struct {
@@ -32,35 +34,40 @@ type Value struct {
}
const (
- // EMPTY is used for a Value with no value set.
+ // EMPTY identifies a Value with no data.
EMPTY Type = iota
- // BOOL is a boolean Type Value.
+ // BOOL identifies a Value containing a bool.
BOOL
- // INT64 is a 64-bit signed integral Type Value.
+ // INT64 identifies a Value containing an int64.
INT64
- // FLOAT64 is a 64-bit floating point Type Value.
+ // FLOAT64 identifies a Value containing a float64.
FLOAT64
- // STRING is a string Type Value.
+ // STRING identifies a Value containing a string.
STRING
- // BOOLSLICE is a slice of booleans Type Value.
+ // BOOLSLICE identifies a Value containing a []bool.
BOOLSLICE
- // INT64SLICE is a slice of 64-bit signed integral numbers Type Value.
+ // INT64SLICE identifies a Value containing a []int64.
INT64SLICE
- // FLOAT64SLICE is a slice of 64-bit floating point numbers Type Value.
+ // FLOAT64SLICE identifies a Value containing a []float64.
FLOAT64SLICE
- // STRINGSLICE is a slice of strings Type Value.
+ // STRINGSLICE identifies a Value containing a []string.
STRINGSLICE
- // BYTESLICE is a slice of bytes Type Value.
+ // BYTESLICE identifies a Value containing a []byte.
BYTESLICE
- // SLICE is a slice of Value Type values.
+ // SLICE identifies a Value containing a []Value.
SLICE
+ // MAP identifies a Value containing a []KeyValue representation of a map.
+ //
+ // Note that MAP values may contain duplicate keys if duplicate keys are
+ // provided when creating the value.
+ MAP
// INVALID is used for a Value with no value set.
//
// Deprecated: Use EMPTY instead as an empty value is a valid value.
INVALID = EMPTY
)
-// BoolValue creates a BOOL Value.
+// BoolValue returns a [Value] for a bool value.
func BoolValue(v bool) Value {
return Value{
vtype: BOOL,
@@ -68,17 +75,31 @@ func BoolValue(v bool) Value {
}
}
-// BoolSliceValue creates a BOOLSLICE Value.
+// BoolSliceValue returns a [Value] for a []bool value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func BoolSliceValue(v []bool) Value {
return Value{vtype: BOOLSLICE, slice: attribute.SliceValue(v)}
}
-// IntValue creates an INT64 Value.
+// IntValue returns a [Value] for an int value.
+//
+// It is provided as a convenience for [Int64Value].
func IntValue(v int) Value {
return Int64Value(int64(v))
}
-// IntSliceValue creates an INT64SLICE Value.
+// IntSliceValue returns a [Value] for a []int value.
+//
+// It is provided as a convenience for [Int64SliceValue].
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func IntSliceValue(v []int) Value {
val := Value{vtype: INT64SLICE}
@@ -104,7 +125,7 @@ func IntSliceValue(v []int) Value {
return val
}
-// Int64Value creates an INT64 Value.
+// Int64Value returns a [Value] for an int64 value.
func Int64Value(v int64) Value {
return Value{
vtype: INT64,
@@ -112,12 +133,17 @@ func Int64Value(v int64) Value {
}
}
-// Int64SliceValue creates an INT64SLICE Value.
+// Int64SliceValue returns a [Value] for a []int64 value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func Int64SliceValue(v []int64) Value {
return Value{vtype: INT64SLICE, slice: attribute.SliceValue(v)}
}
-// Float64Value creates a FLOAT64 Value.
+// Float64Value returns a [Value] for a float64 value.
func Float64Value(v float64) Value {
return Value{
vtype: FLOAT64,
@@ -125,12 +151,17 @@ func Float64Value(v float64) Value {
}
}
-// Float64SliceValue creates a FLOAT64SLICE Value.
+// Float64SliceValue returns a [Value] for a []float64 value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func Float64SliceValue(v []float64) Value {
return Value{vtype: FLOAT64SLICE, slice: attribute.SliceValue(v)}
}
-// StringValue creates a STRING Value.
+// StringValue returns a [Value] for a string value.
func StringValue(v string) Value {
return Value{
vtype: STRING,
@@ -138,12 +169,22 @@ func StringValue(v string) Value {
}
}
-// StringSliceValue creates a STRINGSLICE Value.
+// StringSliceValue returns a [Value] for a []string value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func StringSliceValue(v []string) Value {
return Value{vtype: STRINGSLICE, slice: attribute.SliceValue(v)}
}
-// ByteSliceValue creates a BYTESLICE Value.
+// ByteSliceValue returns a [Value] for a []byte value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func ByteSliceValue(v []byte) Value {
return Value{
vtype: BYTESLICE,
@@ -151,12 +192,32 @@ func ByteSliceValue(v []byte) Value {
}
}
-// SliceValue creates a SLICE Value.
+// SliceValue returns a [Value] for a []Value value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
func SliceValue(v ...Value) Value {
return Value{vtype: SLICE, slice: sliceValue(v)}
}
-// Type returns a type of the Value.
+// MapValue returns a [Value] for a []KeyValue value.
+//
+// Note that many observability backends are not optimized to query, index, or
+// aggregate complex attribute values. Complex values may also carry
+// additional performance overhead. Prefer primitive values when
+// possible.
+//
+// Users should avoid providing duplicate keys; many receivers handle maps
+// containing duplicate keys unpredictably.
+//
+// The order of v is not preserved.
+func MapValue(v ...KeyValue) Value {
+ return Value{vtype: MAP, slice: mapValue(v)}
+}
+
+// Type returns v's type.
func (v Value) Type() Type {
return v.vtype
}
@@ -277,6 +338,53 @@ func asValueSliceReflect(v any) []Value {
return cpy
}
+// AsMap returns the []KeyValue value. Make sure that the Value's type is
+// MAP.
+//
+// The returned slice is sorted by key and may differ from the order
+// provided when creating the map value.
+//
+// The returned slice may contain duplicate keys if duplicate keys were
+// provided when creating the map value. Callers should not assume the returned
+// keys are unique.
+func (v Value) AsMap() []KeyValue {
+ if v.vtype != MAP {
+ return nil
+ }
+ return v.asMap()
+}
+
+func (v Value) asMap() []KeyValue {
+ switch vals := v.slice.(type) {
+ case [0]KeyValue:
+ return []KeyValue{}
+ case [1]KeyValue:
+ return []KeyValue{vals[0]}
+ case [2]KeyValue:
+ return []KeyValue{vals[0], vals[1]}
+ case [3]KeyValue:
+ return []KeyValue{vals[0], vals[1], vals[2]}
+ case [4]KeyValue:
+ return []KeyValue{vals[0], vals[1], vals[2], vals[3]}
+ case [5]KeyValue:
+ return []KeyValue{vals[0], vals[1], vals[2], vals[3], vals[4]}
+ default:
+ return asKeyValueSliceReflect(v.slice)
+ }
+}
+
+func asKeyValueSliceReflect(v any) []KeyValue {
+ rv := reflect.ValueOf(v)
+ if !rv.IsValid() || rv.Kind() != reflect.Array || rv.Type().Elem() != reflect.TypeFor[KeyValue]() {
+ return nil
+ }
+ cpy := make([]KeyValue, rv.Len())
+ if len(cpy) > 0 {
+ _ = reflect.Copy(reflect.ValueOf(cpy), rv)
+ }
+ return cpy
+}
+
// AsByteSlice returns the bytes value. Make sure that the Value's type
// is BYTESLICE.
func (v Value) AsByteSlice() []byte {
@@ -315,6 +423,8 @@ func (v Value) AsInterface() any {
return v.asByteSlice()
case SLICE:
return v.asSlice()
+ case MAP:
+ return v.asMap()
case EMPTY:
return nil
}
@@ -327,10 +437,10 @@ func (v Value) AsInterface() any {
// Strings are returned as-is without JSON quoting, booleans and integers use
// JSON literals, floating-point values use JSON numbers except that NaN and
// ±Inf are rendered as NaN, Infinity, and -Infinity, byte slices are
-// base64-encoded, empty values are the empty string, and slices are encoded as
-// JSON arrays. String, byte, and special floating-point values inside arrays
-// are encoded as JSON strings, and empty values inside arrays are encoded as
-// null.
+// base64-encoded, empty values are the empty string, slices are encoded as JSON
+// arrays, and maps are encoded as JSON objects. String, byte, and special
+// floating-point values inside arrays and maps are encoded as JSON strings, and
+// empty values inside arrays and maps are encoded as null.
//
// [OpenTelemetry AnyValue representation for non-OTLP protocols]: https://opentelemetry.io/docs/specs/otel/common/#anyvalue-representation-for-non-otlp-protocols
func (v Value) String() string {
@@ -355,6 +465,8 @@ func (v Value) String() string {
return formatByteSlice(v.stringly)
case SLICE:
return formatValueSliceValue(v.slice)
+ case MAP:
+ return formatMapValue(v.slice)
case EMPTY:
return ""
default:
@@ -399,6 +511,8 @@ func (v Value) Emit() string {
return formatByteSlice(v.stringly)
case SLICE:
return formatValueSliceValue(v.slice)
+ case MAP:
+ return formatMapValue(v.slice)
case EMPTY:
return ""
default:
@@ -439,6 +553,47 @@ func sliceValueReflect(v []Value) any {
return cp.Interface()
}
+func mapValue(v []KeyValue) any {
+ switch len(v) {
+ case 0:
+ return [0]KeyValue{}
+ case 1:
+ return [1]KeyValue{v[0]}
+ case 2:
+ vals := [2]KeyValue{v[0], v[1]}
+ sortKeyValues(vals[:])
+ return vals
+ case 3:
+ vals := [3]KeyValue{v[0], v[1], v[2]}
+ sortKeyValues(vals[:])
+ return vals
+ case 4:
+ vals := [4]KeyValue{v[0], v[1], v[2], v[3]}
+ sortKeyValues(vals[:])
+ return vals
+ case 5:
+ vals := [5]KeyValue{v[0], v[1], v[2], v[3], v[4]}
+ sortKeyValues(vals[:])
+ return vals
+ default:
+ return mapValueReflect(v)
+ }
+}
+
+func mapValueReflect(v []KeyValue) any {
+ cp := reflect.New(reflect.ArrayOf(len(v), reflect.TypeFor[KeyValue]())).Elem()
+ reflect.Copy(cp, reflect.ValueOf(v))
+ vals := cp.Slice(0, len(v)).Interface().([]KeyValue)
+ sortKeyValues(vals)
+ return cp.Interface()
+}
+
+func sortKeyValues(vals []KeyValue) {
+ slices.SortStableFunc(vals, func(a, b KeyValue) int {
+ return cmp.Compare(a.Key, b.Key)
+ })
+}
+
func formatBoolSliceValue(v any) string {
switch vals := v.(type) {
case [0]bool:
@@ -807,6 +962,37 @@ func formatValueSliceReflect(v any) string {
return b.String()
}
+func formatMapValue(v any) string {
+ switch vals := v.(type) {
+ case [0]KeyValue:
+ return "{}"
+ case [1]KeyValue:
+ return formatMap(vals[:])
+ case [2]KeyValue:
+ return formatMap(vals[:])
+ case [3]KeyValue:
+ return formatMap(vals[:])
+ case [4]KeyValue:
+ return formatMap(vals[:])
+ case [5]KeyValue:
+ return formatMap(vals[:])
+ default:
+ return formatMapReflect(v)
+ }
+}
+
+func formatMap(vals []KeyValue) string {
+ var b strings.Builder
+ appendMap(&b, vals)
+ return b.String()
+}
+
+func formatMapReflect(v any) string {
+ var b strings.Builder
+ appendMapReflect(&b, reflect.ValueOf(v))
+ return b.String()
+}
+
func appendValueSliceValue(dst *strings.Builder, v any) {
switch vals := v.(type) {
case [0]Value:
@@ -852,6 +1038,68 @@ func appendValueSliceReflect(dst *strings.Builder, rv reflect.Value) {
_ = dst.WriteByte(']')
}
+func appendMapValue(dst *strings.Builder, v any) {
+ switch vals := v.(type) {
+ case [0]KeyValue:
+ _, _ = dst.WriteString("{}")
+ case [1]KeyValue:
+ appendMap(dst, vals[:])
+ case [2]KeyValue:
+ appendMap(dst, vals[:])
+ case [3]KeyValue:
+ appendMap(dst, vals[:])
+ case [4]KeyValue:
+ appendMap(dst, vals[:])
+ case [5]KeyValue:
+ appendMap(dst, vals[:])
+ default:
+ appendMapReflect(dst, reflect.ValueOf(v))
+ }
+}
+
+func appendMap(dst *strings.Builder, vals []KeyValue) {
+ // Estimate 32 bytes per value for small values, plus key quotes, colon,
+ // and commas. Escaped keys and larger values grow the builder as needed.
+ size := len("{}") + len(vals)*commaLen + len(vals)*32
+ for _, val := range vals {
+ size += len(val.Key) + len(`"":`)
+ }
+
+ dst.Grow(size)
+ _ = dst.WriteByte('{')
+ for i, val := range vals {
+ if i > 0 {
+ _ = dst.WriteByte(',')
+ }
+ appendJSONString(dst, string(val.Key))
+ _ = dst.WriteByte(':')
+ appendJSONValue(dst, val.Value)
+ }
+ _ = dst.WriteByte('}')
+}
+
+func appendMapReflect(dst *strings.Builder, rv reflect.Value) {
+ // Estimate 32 bytes per value for small values, plus key quotes, colon,
+ // and commas. Escaped keys and larger values grow the builder as needed.
+ size := len("{}") + rv.Len()*commaLen + rv.Len()*32
+ for i := 0; i < rv.Len(); i++ {
+ size += len(rv.Index(i).Field(0).String()) + len(`"":`)
+ }
+
+ dst.Grow(size)
+ _ = dst.WriteByte('{')
+ for i := 0; i < rv.Len(); i++ {
+ if i > 0 {
+ _ = dst.WriteByte(',')
+ }
+ val := rv.Index(i).Interface().(KeyValue)
+ appendJSONString(dst, string(val.Key))
+ _ = dst.WriteByte(':')
+ appendJSONValue(dst, val.Value)
+ }
+ _ = dst.WriteByte('}')
+}
+
func appendJSONValue(dst *strings.Builder, v Value) {
switch v.Type() {
case BOOL:
@@ -894,6 +1142,8 @@ func appendJSONValue(dst *strings.Builder, v Value) {
_ = dst.WriteByte('"')
case SLICE:
appendValueSliceValue(dst, v.slice)
+ case MAP:
+ appendMapValue(dst, v.slice)
case EMPTY:
_, _ = dst.WriteString("null")
default:
diff --git a/vendor/go.opentelemetry.io/otel/baggage/baggage.go b/vendor/go.opentelemetry.io/otel/baggage/baggage.go
index b290c6d6c..25c739d08 100644
--- a/vendor/go.opentelemetry.io/otel/baggage/baggage.go
+++ b/vendor/go.opentelemetry.io/otel/baggage/baggage.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package baggage // import "go.opentelemetry.io/otel/baggage"
+package baggage
import (
"errors"
diff --git a/vendor/go.opentelemetry.io/otel/baggage/context.go b/vendor/go.opentelemetry.io/otel/baggage/context.go
index a572461a0..4d09b59aa 100644
--- a/vendor/go.opentelemetry.io/otel/baggage/context.go
+++ b/vendor/go.opentelemetry.io/otel/baggage/context.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package baggage // import "go.opentelemetry.io/otel/baggage"
+package baggage
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/baggage/doc.go b/vendor/go.opentelemetry.io/otel/baggage/doc.go
index b51d87cab..74d3a8709 100644
--- a/vendor/go.opentelemetry.io/otel/baggage/doc.go
+++ b/vendor/go.opentelemetry.io/otel/baggage/doc.go
@@ -6,4 +6,4 @@ Package baggage provides functionality for storing and retrieving
baggage items in Go context. For propagating the baggage, see the
go.opentelemetry.io/otel/propagation package.
*/
-package baggage // import "go.opentelemetry.io/otel/baggage"
+package baggage
diff --git a/vendor/go.opentelemetry.io/otel/codes/codes.go b/vendor/go.opentelemetry.io/otel/codes/codes.go
index d48847ed8..9355545a8 100644
--- a/vendor/go.opentelemetry.io/otel/codes/codes.go
+++ b/vendor/go.opentelemetry.io/otel/codes/codes.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package codes // import "go.opentelemetry.io/otel/codes"
+package codes
import (
"encoding/json"
@@ -81,7 +81,7 @@ func (c *Code) UnmarshalJSON(b []byte) error {
case float64:
if ci, err := strconv.ParseUint(string(b), 10, 32); err == nil {
if ci >= maxCode {
- return fmt.Errorf("invalid code: %q", ci)
+ return fmt.Errorf("invalid code: %d", ci)
}
*c = Code(ci) // nolint: gosec // Bit size of 32 check above.
diff --git a/vendor/go.opentelemetry.io/otel/codes/doc.go b/vendor/go.opentelemetry.io/otel/codes/doc.go
index ee8db448b..1073f6543 100644
--- a/vendor/go.opentelemetry.io/otel/codes/doc.go
+++ b/vendor/go.opentelemetry.io/otel/codes/doc.go
@@ -7,4 +7,4 @@ Package codes defines the canonical error codes used by OpenTelemetry.
It conforms to [the OpenTelemetry
specification](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/trace/api.md#set-status).
*/
-package codes // import "go.opentelemetry.io/otel/codes"
+package codes
diff --git a/vendor/go.opentelemetry.io/otel/dependencies.Dockerfile b/vendor/go.opentelemetry.io/otel/dependencies.Dockerfile
index 74fa510bc..20eecba40 100644
--- a/vendor/go.opentelemetry.io/otel/dependencies.Dockerfile
+++ b/vendor/go.opentelemetry.io/otel/dependencies.Dockerfile
@@ -1,4 +1,4 @@
# This is a renovate-friendly source of Docker images.
FROM python:3.13.6-slim-bullseye@sha256:e98b521460ee75bca92175c16247bdf7275637a8faaeb2bcfa19d879ae5c4b9a AS python
-FROM otel/weaver:v0.23.0@sha256:7984ecb55b859eb3034ae9d836c4eeda137e2bdd0873b7ba2bb6c3d24d6ff457 AS weaver
+FROM otel/weaver:v0.25.1@sha256:9ad46ca9cd4fa5974b121f886aa3e9946a8ef8ea905001a96c018d21f9db87ca AS weaver
FROM avtodev/markdown-lint:v1@sha256:6aeedc2f49138ce7a1cd0adffc1b1c0321b841dc2102408967d9301c031949ee AS markdown
diff --git a/vendor/go.opentelemetry.io/otel/doc.go b/vendor/go.opentelemetry.io/otel/doc.go
index 921f85961..92b7a0566 100644
--- a/vendor/go.opentelemetry.io/otel/doc.go
+++ b/vendor/go.opentelemetry.io/otel/doc.go
@@ -22,4 +22,4 @@ To read more about logs, see go.opentelemetry.io/otel/log.
To read more about propagation, see go.opentelemetry.io/otel/propagation and
go.opentelemetry.io/otel/baggage.
*/
-package otel // import "go.opentelemetry.io/otel"
+package otel
diff --git a/vendor/go.opentelemetry.io/otel/error_handler.go b/vendor/go.opentelemetry.io/otel/error_handler.go
index 67414c71e..06fd49da2 100644
--- a/vendor/go.opentelemetry.io/otel/error_handler.go
+++ b/vendor/go.opentelemetry.io/otel/error_handler.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
// ErrorHandler handles irremediable events.
type ErrorHandler interface {
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go
index 5488a4c62..8a88b802e 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/client.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+package otlploggrpc
import (
"context"
@@ -103,10 +103,12 @@ func newGRPCDialOptions(cfg config) []grpc.DialOption {
if cfg.serviceConfig.Value != "" {
dialOpts = append(dialOpts, grpc.WithDefaultServiceConfig(cfg.serviceConfig.Value))
}
- // Prioritize GRPCCredentials over Insecure (passing both is an error).
+ // Prioritize configured credentials over Insecure (passing both is an error).
switch {
case cfg.gRPCCredentials.Value != nil:
dialOpts = append(dialOpts, grpc.WithTransportCredentials(cfg.gRPCCredentials.Value))
+ case cfg.tlsCfg.Value != nil:
+ dialOpts = append(dialOpts, grpc.WithTransportCredentials(credentials.NewTLS(cfg.tlsCfg.Value)))
case cfg.insecure.Value:
dialOpts = append(dialOpts, grpc.WithTransportCredentials(insecure.NewCredentials()))
default:
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go
index 6f8a0f9d1..a872d7b35 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/config.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+package otlploggrpc
import (
"crypto/tls"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go
index 67cb81434..a159ad304 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/doc.go
@@ -60,4 +60,4 @@ The configuration can be overridden by [WithTLSCredentials], [WithGRPCConn] opti
[W3C Baggage HTTP Header Content Format]: https://www.w3.org/TR/baggage/#header-content
*/
-package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+package otlploggrpc
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go
index 898eecf77..63ef9252a 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/exporter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+package otlploggrpc
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go
index 797bfc95c..40627daab 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/gen.go
@@ -3,9 +3,9 @@
// Package internal provides internal functionality for the otlploggrpc
// package.
-package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal"
+package internal
-//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target.go.tmpl "--data={ \"pkg\": \"observ\", \"pkg_path\": \"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ\" }" --out=observ/target.go
+//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target.go.tmpl "--data={ \"pkg\": \"observ\" }" --out=observ/target.go
//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target_test.go.tmpl "--data={ \"pkg\": \"observ\" }" --out=observ/target_test.go
//go:generate gotmpl --body=../../../../../internal/shared/x/x.go.tmpl "--data={ \"pkg\": \"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc\" }" --out=x/x.go
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go
index 7f2ecab71..2058f51c4 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/instrumentation.go
@@ -3,7 +3,7 @@
// Package observ provides observability metrics for OTLP log exporters.
// This is an experimental feature controlled by the x.Observability feature flag.
-package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ"
+package observ
import (
"context"
@@ -21,8 +21,8 @@ import (
"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x"
"go.opentelemetry.io/otel/internal/global"
"go.opentelemetry.io/otel/metric"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
const (
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go
index 186f00e52..4d0665894 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ/target.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/observ/target.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/observ/target.go.tmpl
+
+package observ
import (
"errors"
@@ -41,11 +41,10 @@ func ParseCanonicalTarget(target string) (string, int, error) {
const sep = "://"
// Find scheme. Do not allocate the string by using url.Parse.
- idx := strings.Index(target, sep)
- if idx == -1 {
+ scheme, endpoint, found := strings.Cut(target, sep)
+ if !found {
return "", -1, fmt.Errorf("invalid target %q: missing scheme", target)
}
- scheme, endpoint := target[:idx], target[idx+len(sep):]
// Check for unix schemes.
if scheme == schemeUnix || scheme == schemeUnixAbstract {
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go
index 076f05fcf..455df0e0d 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/partialsuccess.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal"
+package internal
import "fmt"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go
index 1a5684d6e..1883d0600 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry/retry.go
@@ -1,13 +1,13 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/retry/retry.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/retry/retry.go.tmpl
+
// Package retry provides request retry functionality that can perform
// configurable exponential backoff for transient errors and honor any
// explicit throttle responses received.
-package retry // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry"
+package retry
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go
index aa6eb510b..721e4eb3b 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform/log.go
@@ -1,12 +1,12 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/otlplog/transform/log.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/otlplog/transform/log.go.tmpl
+
// Package transform provides transformation functionality from the
// sdk/log data-types into OTLP data-types.
-package transform // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform"
+package transform
import (
"time"
@@ -94,13 +94,13 @@ func LogRecord(record log.Record) *lpb.LogRecord {
EventName: record.EventName(),
SeverityNumber: SeverityNumber(record.Severity()),
SeverityText: record.SeverityText(),
- Body: LogAttrValue(record.Body()),
+ Body: AttrValue(record.Body()),
Attributes: make([]*cpb.KeyValue, 0, record.AttributesLen()),
Flags: uint32(record.TraceFlags()),
// TODO: DroppedAttributesCount: /* ... */,
}
- record.WalkAttributes(func(kv api.KeyValue) bool {
- r.Attributes = append(r.Attributes, LogAttr(kv))
+ record.WalkAttributes(func(kv attribute.KeyValue) bool {
+ r.Attributes = append(r.Attributes, Attr(kv))
return true
})
if tID := record.TraceID(); tID.IsValid() {
@@ -205,6 +205,12 @@ func AttrValue(v attribute.Value) *cpb.AnyValue {
Values: attrValues(v.AsSlice()),
},
}
+ case attribute.MAP:
+ av.Value = &cpb.AnyValue_KvlistValue{
+ KvlistValue: &cpb.KeyValueList{
+ Values: Attrs(v.AsMap()),
+ },
+ }
case attribute.STRINGSLICE:
av.Value = &cpb.AnyValue_ArrayValue{
ArrayValue: &cpb.ArrayValue{
@@ -276,85 +282,6 @@ func attrValues(vals []attribute.Value) []*cpb.AnyValue {
return converted
}
-// LogAttrs transforms a slice of [api.KeyValue] into OTLP key-values.
-func LogAttrs(attrs []api.KeyValue) []*cpb.KeyValue {
- if len(attrs) == 0 {
- return nil
- }
-
- out := make([]*cpb.KeyValue, 0, len(attrs))
- for _, kv := range attrs {
- out = append(out, LogAttr(kv))
- }
- return out
-}
-
-// LogAttr transforms an [api.KeyValue] into an OTLP key-value.
-func LogAttr(attr api.KeyValue) *cpb.KeyValue {
- return &cpb.KeyValue{
- Key: attr.Key,
- Value: LogAttrValue(attr.Value),
- }
-}
-
-// LogAttrValues transforms a slice of [api.Value] into an OTLP []AnyValue.
-func LogAttrValues(vals []api.Value) []*cpb.AnyValue {
- if len(vals) == 0 {
- return nil
- }
-
- out := make([]*cpb.AnyValue, 0, len(vals))
- for _, v := range vals {
- out = append(out, LogAttrValue(v))
- }
- return out
-}
-
-// LogAttrValue transforms an [api.Value] into an OTLP AnyValue.
-func LogAttrValue(v api.Value) *cpb.AnyValue {
- av := new(cpb.AnyValue)
- switch v.Kind() {
- case api.KindBool:
- av.Value = &cpb.AnyValue_BoolValue{
- BoolValue: v.AsBool(),
- }
- case api.KindInt64:
- av.Value = &cpb.AnyValue_IntValue{
- IntValue: v.AsInt64(),
- }
- case api.KindFloat64:
- av.Value = &cpb.AnyValue_DoubleValue{
- DoubleValue: v.AsFloat64(),
- }
- case api.KindString:
- av.Value = &cpb.AnyValue_StringValue{
- StringValue: v.AsString(),
- }
- case api.KindBytes:
- av.Value = &cpb.AnyValue_BytesValue{
- BytesValue: v.AsBytes(),
- }
- case api.KindSlice:
- av.Value = &cpb.AnyValue_ArrayValue{
- ArrayValue: &cpb.ArrayValue{
- Values: LogAttrValues(v.AsSlice()),
- },
- }
- case api.KindMap:
- av.Value = &cpb.AnyValue_KvlistValue{
- KvlistValue: &cpb.KeyValueList{
- Values: LogAttrs(v.AsMap()),
- },
- }
- case api.KindEmpty:
- default:
- av.Value = &cpb.AnyValue_StringValue{
- StringValue: "INVALID",
- }
- }
- return av
-}
-
// SeverityNumber transforms a [log.Severity] into an OTLP SeverityNumber.
func SeverityNumber(s api.Severity) lpb.SeverityNumber {
switch s {
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go
index 9dffad62c..8741594f3 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/version.go
@@ -1,8 +1,8 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal"
+package internal
// Version is the current release version of the OpenTelemetry otlploggrpc
// exporter in use.
-const Version = "0.20.0"
+const Version = "0.21.0"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go
index 0ed1c81aa..7b66b367c 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/features.go
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// Package x documents experimental features for [go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc].
-package x // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x"
+package x
import "strings"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go
index e2d50cede..7b6363673 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x/x.go
@@ -1,11 +1,11 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/x/x.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/x/x.go.tmpl
+
// Package x documents experimental features for [go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc].
-package x // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x"
+package x
import (
"os"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go
index 818ecf9e9..6aff6b221 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/version.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
+package otlploggrpc
// Version is the current release version of the OpenTelemetry OTLP over gRPC logs exporter in use.
func Version() string {
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/clients.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/clients.go
index 3c1a625c0..d97fada29 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/clients.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/clients.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlptrace // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+package otlptrace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/doc.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/doc.go
index 09ad5eadb..5fd4bf5bb 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/doc.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/doc.go
@@ -7,4 +7,4 @@ See the official OTLP span exporter implementations:
- [go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc],
- [go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp].
*/
-package otlptrace // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+package otlptrace
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/exporter.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/exporter.go
index 30446bd28..037d485d5 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/exporter.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/exporter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlptrace // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+package otlptrace
import (
"context"
@@ -97,9 +97,9 @@ func NewUnstarted(client Client) *Exporter {
func (e *Exporter) MarshalLog() any {
return struct {
Type string
- Client Client
+ Client string
}{
Type: "otlptrace",
- Client: e.client,
+ Client: fmt.Sprintf("%T", e.client),
}
}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/attribute.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/attribute.go
index 0d43a5dc5..86a34d3b9 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/attribute.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/attribute.go
@@ -3,7 +3,7 @@
// Package tracetransform provides conversion functionality for the otlptrace
// exporters.
-package tracetransform // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform"
+package tracetransform
import (
commonpb "go.opentelemetry.io/proto/otlp/common/v1"
@@ -97,6 +97,12 @@ func Value(v attribute.Value) *commonpb.AnyValue {
Values: values(v.AsSlice()),
},
}
+ case attribute.MAP:
+ av.Value = &commonpb.AnyValue_KvlistValue{
+ KvlistValue: &commonpb.KeyValueList{
+ Values: KeyValues(v.AsMap()),
+ },
+ }
case attribute.STRINGSLICE:
av.Value = &commonpb.AnyValue_ArrayValue{
ArrayValue: &commonpb.ArrayValue{
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go
index 43359c894..078a9db0a 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package tracetransform // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform"
+package tracetransform
import (
commonpb "go.opentelemetry.io/proto/otlp/common/v1"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/resource.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/resource.go
index 526bb5e07..14e5bdc56 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/resource.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/resource.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package tracetransform // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform"
+package tracetransform
import (
resourcepb "go.opentelemetry.io/proto/otlp/resource/v1"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/span.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/span.go
index d431fc451..3ab14b54f 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/span.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/span.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package tracetransform // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform"
+package tracetransform
import (
"math"
@@ -37,21 +37,22 @@ func Spans(sdl []tracesdk.ReadOnlySpan) []*tracepb.ResourceSpans {
}
rKey := sd.Resource().Equivalent()
+ scope := sd.InstrumentationScope()
k := key{
r: rKey,
- is: sd.InstrumentationScope(),
+ is: scope,
}
scopeSpan, iOk := ssm[k]
if !iOk {
// Either the resource or instrumentation scope were unknown.
scopeSpan = &tracepb.ScopeSpans{
- Scope: InstrumentationScope(sd.InstrumentationScope()),
+ Scope: InstrumentationScope(scope),
Spans: []*tracepb.Span{},
- SchemaUrl: sd.InstrumentationScope().SchemaURL,
+ SchemaUrl: scope.SchemaURL,
}
+ ssm[k] = scopeSpan
}
scopeSpan.Spans = append(scopeSpan.Spans, span(sd))
- ssm[k] = scopeSpan
rs, rOk := rsm[rKey]
if !rOk {
@@ -90,14 +91,16 @@ func span(sd tracesdk.ReadOnlySpan) *tracepb.Span {
return nil
}
- tid := sd.SpanContext().TraceID()
- sid := sd.SpanContext().SpanID()
+ spanContext := sd.SpanContext()
+ tid := spanContext.TraceID()
+ sid := spanContext.SpanID()
+ sdStatus := sd.Status()
s := &tracepb.Span{
TraceId: tid[:],
SpanId: sid[:],
- TraceState: sd.SpanContext().TraceState().String(),
- Status: status(sd.Status().Code, sd.Status().Description),
+ TraceState: spanContext.TraceState().String(),
+ Status: status(sdStatus.Code, sdStatus.Description),
StartTimeUnixNano: uint64(max(0, sd.StartTime().UnixNano())), // nolint:gosec // Overflow checked.
EndTimeUnixNano: uint64(max(0, sd.EndTime().UnixNano())), // nolint:gosec // Overflow checked.
Links: links(sd.Links()),
@@ -110,10 +113,11 @@ func span(sd tracesdk.ReadOnlySpan) *tracepb.Span {
DroppedLinksCount: clampUint32(sd.DroppedLinks()),
}
- if psid := sd.Parent().SpanID(); psid.IsValid() {
+ sdParent := sd.Parent()
+ if psid := sdParent.SpanID(); psid.IsValid() {
s.ParentSpanId = psid[:]
}
- s.Flags = buildSpanFlagsWith(sd.SpanContext().TraceFlags(), sd.Parent())
+ s.Flags = buildSpanFlagsWith(spanContext.TraceFlags(), sdParent)
return s
}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go
index e8b33d3fa..494bece44 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlptracegrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+package otlptracegrpc
import (
"context"
@@ -328,12 +328,10 @@ func throttleDelay(s *status.Status) (bool, time.Duration) {
}
// MarshalLog is the marshaling function used by the logging system to represent this Client.
-func (c *client) MarshalLog() any {
+func (*client) MarshalLog() any {
return struct {
- Type string
- Endpoint string
+ Type string
}{
- Type: "otlptracegrpc",
- Endpoint: c.endpoint,
+ Type: "otlptracegrpc",
}
}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/doc.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/doc.go
index b7bd429ff..b01358fc8 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/doc.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/doc.go
@@ -62,4 +62,4 @@ The configuration can be overridden by [WithTLSCredentials], [WithGRPCConn] opti
[W3C Baggage HTTP Header Content Format]: https://www.w3.org/TR/baggage/#header-content
*/
-package otlptracegrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+package otlptracegrpc
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/exporter.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/exporter.go
index b826b8424..d75b18443 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/exporter.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/exporter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlptracegrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+package otlptracegrpc
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter/counter.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter/counter.go
index 323b2a2c9..57c6acb78 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter/counter.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter/counter.go
@@ -1,14 +1,14 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/counter/counter.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/counter/counter.go.tmpl
+
// Package counter provides a simple counter for generating unique IDs.
//
// This package is used to generate unique IDs while allowing testing packages
// to reset the counter.
-package counter // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter"
+package counter
import "sync/atomic"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/envconfig/envconfig.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/envconfig/envconfig.go
index 6eacdf311..87764a695 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/envconfig/envconfig.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/envconfig/envconfig.go
@@ -1,12 +1,12 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/envconfig/envconfig.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/envconfig/envconfig.go.tmpl
+
// Package envconfig provides functionality to parse configuration from
// environment variables.
-package envconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/envconfig"
+package envconfig
import (
"crypto/tls"
@@ -60,7 +60,7 @@ func WithString(n string, fn func(string)) func(e *EnvOptionsReader) {
func WithBool(n string, fn func(bool)) ConfigFn {
return func(e *EnvOptionsReader) {
if v, ok := e.GetEnvValue(n); ok {
- b := strings.ToLower(v) == "true"
+ b := strings.EqualFold(v, "true")
fn(b)
}
}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/gen.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/gen.go
index 7fe9c9f3a..ec16d0145 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/gen.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/gen.go
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// Package internal provides internal functionally for the otlptracegrpc package.
-package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal"
+package internal
//go:generate gotmpl --body=../../../../../internal/shared/otlp/partialsuccess.go.tmpl "--data={}" --out=partialsuccess.go
//go:generate gotmpl --body=../../../../../internal/shared/otlp/partialsuccess_test.go.tmpl "--data={}" --out=partialsuccess_test.go
@@ -27,8 +27,8 @@ package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/ot
//go:generate gotmpl --body=../../../../../internal/shared/x/x.go.tmpl "--data={ \"pkg\": \"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc\" }" --out=x/x.go
//go:generate gotmpl --body=../../../../../internal/shared/x/x_test.go.tmpl "--data={}" --out=x/x_test.go
-//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target.go.tmpl "--data={ \"pkg\": \"observ\", \"pkg_path\": \"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ\" }" --out=observ/target.go
+//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target.go.tmpl "--data={ \"pkg\": \"observ\" }" --out=observ/target.go
//go:generate gotmpl --body=../../../../../internal/shared/otlp/observ/target_test.go.tmpl "--data={ \"pkg\": \"observ\" }" --out=observ/target_test.go
-//go:generate gotmpl --body=../../../../../internal/shared/counter/counter.go.tmpl "--data={ \"pkg\": \"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter\" }" --out=counter/counter.go
+//go:generate gotmpl --body=../../../../../internal/shared/counter/counter.go.tmpl "--data={}" --out=counter/counter.go
//go:generate gotmpl --body=../../../../../internal/shared/counter/counter_test.go.tmpl "--data={}" --out=counter/counter_test.go
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/doc.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/doc.go
index 0dd54e4b9..32188bf72 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/doc.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/doc.go
@@ -3,4 +3,4 @@
// Package observ provides experimental observability instrumentation for the
// otlptracegrpc exporter.
-package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ"
+package observ
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go
index 676a93514..d6730bc1e 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ"
+package observ
import (
"context"
@@ -18,8 +18,8 @@ import (
"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x"
"go.opentelemetry.io/otel/internal/global"
"go.opentelemetry.io/otel/metric"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
const (
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/target.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/target.go
index 34eee27db..4d0665894 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/target.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/target.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/observ/target.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/observ/target.go.tmpl
+
+package observ
import (
"errors"
@@ -41,11 +41,10 @@ func ParseCanonicalTarget(target string) (string, int, error) {
const sep = "://"
// Find scheme. Do not allocate the string by using url.Parse.
- idx := strings.Index(target, sep)
- if idx == -1 {
+ scheme, endpoint, found := strings.Cut(target, sep)
+ if !found {
return "", -1, fmt.Errorf("invalid target %q: missing scheme", target)
}
- scheme, endpoint := target[:idx], target[idx+len(sep):]
// Check for unix schemes.
if scheme == schemeUnix || scheme == schemeUnixAbstract {
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/envconfig.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/envconfig.go
index 1d840be20..8b3f729fd 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/envconfig.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/envconfig.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/otlptrace/otlpconfig/envconfig.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/otlptrace/otlpconfig/envconfig.go.tmpl
+
+package otlpconfig
import (
"crypto/tls"
@@ -49,31 +49,37 @@ func getOptionsFromEnv() []GenericOption {
tlsConf := &tls.Config{}
DefaultEnvOptionsReader.Apply(
envconfig.WithURL("ENDPOINT", func(u *url.URL) {
- opts = append(opts, withEndpointScheme(u))
- opts = append(opts, newSplitOption(func(cfg Config) Config {
- cfg.Traces.Endpoint = u.Host
- // For OTLP/HTTP endpoint URLs without a per-signal
- // configuration, the passed endpoint is used as a base URL
- // and the signals are sent to these paths relative to that.
- cfg.Traces.URLPath = path.Join(u.Path, DefaultTracesPath)
- return cfg
- }, withEndpointForGRPC(u)))
+ opts = append(
+ opts,
+ withEndpointScheme(u),
+ newSplitOption(func(cfg Config) Config {
+ cfg.Traces.Endpoint = u.Host
+ // For OTLP/HTTP endpoint URLs without a per-signal
+ // configuration, the passed endpoint is used as a base URL
+ // and the signals are sent to these paths relative to that.
+ cfg.Traces.URLPath = path.Join(u.Path, DefaultTracesPath)
+ return cfg
+ }, withEndpointForGRPC(u)),
+ )
}),
envconfig.WithURL("TRACES_ENDPOINT", func(u *url.URL) {
- opts = append(opts, withEndpointScheme(u))
- opts = append(opts, newSplitOption(func(cfg Config) Config {
- cfg.Traces.Endpoint = u.Host
- // For endpoint URLs for OTLP/HTTP per-signal variables, the
- // URL MUST be used as-is without any modification. The only
- // exception is that if an URL contains no path part, the root
- // path / MUST be used.
- path := u.Path
- if path == "" {
- path = "/"
- }
- cfg.Traces.URLPath = path
- return cfg
- }, withEndpointForGRPC(u)))
+ opts = append(
+ opts,
+ withEndpointScheme(u),
+ newSplitOption(func(cfg Config) Config {
+ cfg.Traces.Endpoint = u.Host
+ // For endpoint URLs for OTLP/HTTP per-signal variables, the
+ // URL MUST be used as-is without any modification. The only
+ // exception is that if an URL contains no path part, the root
+ // path / MUST be used.
+ path := u.Path
+ if path == "" {
+ path = "/"
+ }
+ cfg.Traces.URLPath = path
+ return cfg
+ }, withEndpointForGRPC(u)),
+ )
}),
envconfig.WithCertPool("CERTIFICATE", func(p *x509.CertPool) { tlsConf.RootCAs = p }),
envconfig.WithCertPool("TRACES_CERTIFICATE", func(p *x509.CertPool) { tlsConf.RootCAs = p }),
@@ -142,7 +148,7 @@ func withInsecure(b bool) GenericOption {
}
func withTLSConfig(c *tls.Config, fn func(*tls.Config)) func(e *envconfig.EnvOptionsReader) {
- return func(e *envconfig.EnvOptionsReader) {
+ return func(*envconfig.EnvOptionsReader) {
if c.RootCAs != nil || len(c.Certificates) > 0 {
fn(c)
}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/options.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/options.go
index d940b6762..36cf1e267 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/options.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/options.go
@@ -1,11 +1,11 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/otlptrace/otlpconfig/options.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/otlptrace/otlpconfig/options.go.tmpl
+
// Package otlpconfig provides configuration for the otlptrace exporters.
-package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig"
+package otlpconfig
import (
"crypto/tls"
@@ -99,7 +99,7 @@ func NewHTTPConfig(opts ...HTTPOption) Config {
// cleanPath returns a path with all spaces trimmed. If urlPath is empty,
// defaultPath is returned instead.
-func cleanPath(urlPath string, defaultPath string) string {
+func cleanPath(urlPath, defaultPath string) string {
tmp := strings.TrimSpace(urlPath)
if tmp == "" || tmp == "." {
return defaultPath
@@ -134,7 +134,7 @@ func NewGRPCConfig(opts ...GRPCOption) Config {
cfg.DialOptions = append(cfg.DialOptions, grpc.WithDefaultServiceConfig(cfg.ServiceConfig))
}
// Prioritize GRPCCredentials over Insecure (passing both is an error).
- if cfg.Traces.GRPCCredentials != nil {
+ if cfg.Traces.GRPCCredentials != nil { //nolint:gocritic // if-else is clearer than switch
cfg.DialOptions = append(cfg.DialOptions, grpc.WithTransportCredentials(cfg.Traces.GRPCCredentials))
} else if cfg.Traces.Insecure {
cfg.DialOptions = append(cfg.DialOptions, grpc.WithTransportCredentials(insecure.NewCredentials()))
@@ -228,7 +228,7 @@ func (g *splitOption) ApplyHTTPOption(cfg Config) Config {
func (splitOption) private() {}
-func newSplitOption(httpFn func(cfg Config) Config, grpcFn func(cfg Config) Config) GenericOption {
+func newSplitOption(httpFn, grpcFn func(cfg Config) Config) GenericOption {
return &splitOption{httpFn: httpFn, grpcFn: grpcFn}
}
@@ -286,6 +286,11 @@ func WithEndpointURL(v string) GenericOption {
cfg.Traces.Endpoint = u.Host
cfg.Traces.URLPath = u.Path
+ if cfg.Traces.URLPath == "" {
+ // For HTTP exporters, a URL without a path targets the root path. Set it explicitly so the default signal
+ // path is not appended by cleanPath. (URLPath is ignored by gRPC exporters.)
+ cfg.Traces.URLPath = "/"
+ }
cfg.Traces.Insecure = u.Scheme != "https"
return cfg
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/optiontypes.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/optiontypes.go
index 918490387..213c3605f 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/optiontypes.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/optiontypes.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/otlptrace/otlpconfig/optiontypes.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/otlptrace/otlpconfig/optiontypes.go.tmpl
+
+package otlpconfig
const (
// DefaultCollectorGRPCPort is the default gRPC port of the collector.
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/tls.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/tls.go
index ba6e41183..a14d5e6ec 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/tls.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig/tls.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/otlptrace/otlpconfig/tls.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/otlptrace/otlpconfig/tls.go.tmpl
+
+package otlpconfig
import (
"crypto/tls"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/partialsuccess.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/partialsuccess.go
index a811a07b3..1138f2e71 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/partialsuccess.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/partialsuccess.go
@@ -1,10 +1,10 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/partialsuccess.go
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal"
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/partialsuccess.go
+
+package internal
import "fmt"
@@ -41,7 +41,7 @@ func (ps PartialSuccess) As(target any) bool {
}
// Is supports the errors.Is() interface.
-func (ps PartialSuccess) Is(err error) bool {
+func (PartialSuccess) Is(err error) bool {
_, ok := err.(PartialSuccess)
return ok
}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry/retry.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry/retry.go
index a7b8e81a7..1883d0600 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry/retry.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry/retry.go
@@ -1,13 +1,13 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/otlp/retry/retry.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/otlp/retry/retry.go.tmpl
+
// Package retry provides request retry functionality that can perform
// configurable exponential backoff for transient errors and honor any
// explicit throttle responses received.
-package retry // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry"
+package retry
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go
index 28e51e443..942d37af7 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go
@@ -1,8 +1,8 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal"
+package internal
// Version is the current release version of the OpenTelemetry OTLP gRPC trace
// exporter in use.
-const Version = "1.44.0"
+const Version = "1.45.0"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/observ.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/observ.go
index 4e89c6524..76b6fdebd 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/observ.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/observ.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package x // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x"
+package x
import "strings"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/x.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/x.go
index 741ba62c9..69ce31eef 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/x.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x/x.go
@@ -1,11 +1,11 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/x/x.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/x/x.go.tmpl
+
// Package x documents experimental features for [go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc].
-package x // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x"
+package x
import (
"os"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/options.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/options.go
index b32006052..ea20363c0 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/options.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/options.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlptracegrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+package otlptracegrpc
import (
"fmt"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go
index d847210db..da70f3f54 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go
@@ -1,9 +1,9 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otlptrace // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+package otlptrace
// Version is the current release version of the OpenTelemetry OTLP trace exporter in use.
func Version() string {
- return "1.44.0"
+ return "1.45.0"
}
diff --git a/vendor/go.opentelemetry.io/otel/handler.go b/vendor/go.opentelemetry.io/otel/handler.go
index 07623b679..1f45ea388 100644
--- a/vendor/go.opentelemetry.io/otel/handler.go
+++ b/vendor/go.opentelemetry.io/otel/handler.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
import (
"go.opentelemetry.io/otel/internal/global"
diff --git a/vendor/go.opentelemetry.io/otel/internal/baggage/baggage.go b/vendor/go.opentelemetry.io/otel/internal/baggage/baggage.go
index b4f85f44a..cbeb14fcd 100644
--- a/vendor/go.opentelemetry.io/otel/internal/baggage/baggage.go
+++ b/vendor/go.opentelemetry.io/otel/internal/baggage/baggage.go
@@ -10,7 +10,7 @@ this need this package would not need to exist and the
`go.opentelemetry.io/otel/baggage` package would be the singular place where
W3C baggage is handled.
*/
-package baggage // import "go.opentelemetry.io/otel/internal/baggage"
+package baggage
// List is the collection of baggage members. The W3C allows for duplicates,
// but OpenTelemetry does not, therefore, this is represented as a map.
diff --git a/vendor/go.opentelemetry.io/otel/internal/baggage/context.go b/vendor/go.opentelemetry.io/otel/internal/baggage/context.go
index 3aea9c491..f3bece165 100644
--- a/vendor/go.opentelemetry.io/otel/internal/baggage/context.go
+++ b/vendor/go.opentelemetry.io/otel/internal/baggage/context.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package baggage // import "go.opentelemetry.io/otel/internal/baggage"
+package baggage
import "context"
diff --git a/vendor/go.opentelemetry.io/otel/internal/errorhandler/errorhandler.go b/vendor/go.opentelemetry.io/otel/internal/errorhandler/errorhandler.go
index 3f0ab3131..de294461c 100644
--- a/vendor/go.opentelemetry.io/otel/internal/errorhandler/errorhandler.go
+++ b/vendor/go.opentelemetry.io/otel/internal/errorhandler/errorhandler.go
@@ -5,7 +5,7 @@
//
// This package has no OTel dependencies, allowing it to be imported by any
// package in the module without creating import cycles.
-package errorhandler // import "go.opentelemetry.io/otel/internal/errorhandler"
+package errorhandler
import (
"errors"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/handler.go b/vendor/go.opentelemetry.io/otel/internal/global/handler.go
index 77d0425f5..6fb8034f8 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/handler.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/handler.go
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// Package global provides the OpenTelemetry global API.
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
import (
"go.opentelemetry.io/otel/internal/errorhandler"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/instruments.go b/vendor/go.opentelemetry.io/otel/internal/global/instruments.go
index 55255cddf..4db3fdcde 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/instruments.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/instruments.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/internal_logging.go b/vendor/go.opentelemetry.io/otel/internal/global/internal_logging.go
index 86d7f4ba0..8e1327354 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/internal_logging.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/internal_logging.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
import (
"log"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/meter.go b/vendor/go.opentelemetry.io/otel/internal/global/meter.go
index 50043d669..48be49037 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/meter.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/meter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
import (
"container/list"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/propagator.go b/vendor/go.opentelemetry.io/otel/internal/global/propagator.go
index 38560ff99..90c462ef0 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/propagator.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/propagator.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/state.go b/vendor/go.opentelemetry.io/otel/internal/global/state.go
index 225c9e501..f8fcb82bc 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/state.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/state.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
import (
"errors"
diff --git a/vendor/go.opentelemetry.io/otel/internal/global/trace.go b/vendor/go.opentelemetry.io/otel/internal/global/trace.go
index bf5cf3119..45899f8c0 100644
--- a/vendor/go.opentelemetry.io/otel/internal/global/trace.go
+++ b/vendor/go.opentelemetry.io/otel/internal/global/trace.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/internal/global"
+package global
/*
This file contains the forwarding implementation of the TracerProvider used as
diff --git a/vendor/go.opentelemetry.io/otel/internal_logging.go b/vendor/go.opentelemetry.io/otel/internal_logging.go
index 6de7f2e4d..3f6b7b10d 100644
--- a/vendor/go.opentelemetry.io/otel/internal_logging.go
+++ b/vendor/go.opentelemetry.io/otel/internal_logging.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
import (
"github.com/go-logr/logr"
diff --git a/vendor/go.opentelemetry.io/otel/log/DESIGN.md b/vendor/go.opentelemetry.io/otel/log/DESIGN.md
index 47d39d34b..d36c96773 100644
--- a/vendor/go.opentelemetry.io/otel/log/DESIGN.md
+++ b/vendor/go.opentelemetry.io/otel/log/DESIGN.md
@@ -62,10 +62,10 @@ Implementation requirements:
- The [specification requires](https://opentelemetry.io/docs/specs/otel/logs/api/#concurrency-requirements)
the method to be safe to be called concurrently.
-- The method should use some default name if the passed name is empty
- in order to meet the [specification's SDK requirement](https://opentelemetry.io/docs/specs/otel/logs/sdk/#logger-creation)
- to return a working logger when an invalid name is passed
- as well as to resemble the behavior of getting tracers and meters.
+- If the passed name is empty, this should be reported as invalid as specified
+ by the [Logs SDK specification](https://opentelemetry.io/docs/specs/otel/logs/sdk/#logger-creation).
+ The method should still use it as the instrumentation scope name and return
+ a working logger.
`Logger` can be extended by adding new `LoggerOption` options
and adding new exported fields to the `LoggerConfig` struct.
@@ -148,16 +148,16 @@ func (r *Record) SetSeverityText(s string)
is accessed using following methods:
```go
-func (r *Record) Body() Value
-func (r *Record) SetBody(v Value)
+func (r *Record) Body() attribute.Value
+func (r *Record) SetBody(v attribute.Value)
```
[Log record attributes](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-attributes)
are accessed using following methods:
```go
-func (r *Record) WalkAttributes(f func(KeyValue) bool)
-func (r *Record) AddAttributes(attrs ...KeyValue)
+func (r *Record) WalkAttributes(f func(attribute.KeyValue) bool)
+func (r *Record) AddAttributes(attrs ...attribute.KeyValue)
```
`Record` has a `AttributesLen` method that returns
@@ -175,49 +175,20 @@ while keeping the API user friendly.
It relieves the user from making his own improvements
for reducing the number of allocations when passing attributes.
-The abstractions described in
-[the specification](https://opentelemetry.io/docs/specs/otel/logs/#new-first-party-application-logs)
-are defined in [keyvalue.go](keyvalue.go).
-
-`Value` is representing `any`.
-`KeyValue` is representing a key(string)-value(`any`) pair.
-
-`Kind` is an enumeration used for specifying the underlying value type.
-`KindEmpty` is used for an empty (zero) value.
-`KindBool` is used for boolean value.
-`KindFloat64` is used for a double precision floating point (IEEE 754-1985) value.
-`KindInt64` is used for a signed integer value.
-`KindString` is used for a string value.
-`KindBytes` is used for a slice of bytes (in spec: A byte array).
-`KindSlice` is used for a slice of values (in spec: an array (a list) of any values).
-`KindMap` is used for a slice of key-value pairs (in spec: `map`).
-
-These types are defined in `go.opentelemetry.io/otel/log` package
-as they are tightly coupled with the API and different from common attributes.
-
-The internal implementation of `Value` is based on
-[`slog.Value`](https://pkg.go.dev/log/slog#Value)
-and the API is mostly inspired by
-[`attribute.Value`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value).
-The benchmarks[^1] show that the implementation is more performant than
-[`attribute.Value`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value).
-
-The value accessors (`func (v Value) As[Kind]` methods) must not panic,
-as it would violate the [specification](https://opentelemetry.io/docs/specs/otel/error-handling/):
-
-> API methods MUST NOT throw unhandled exceptions when used incorrectly by end
-> users. The API and SDK SHOULD provide safe defaults for missing or invalid
-> arguments. [...] Whenever the library suppresses an error that would otherwise
-> have been exposed to the user, the library SHOULD log the error using
-> language-specific conventions.
-
-Therefore, the value accessors should return a zero value
-and log an error when a bad accessor is called.
-
-The `Severity`, `Kind`, `Value`, `KeyValue` may implement
-the [`fmt.Stringer`](https://pkg.go.dev/fmt#Stringer) interface.
-However, it is not needed for the first stable release
-and the `String` methods can be added later.
+Log body and attributes use the common
+[`attribute.Value`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#Value)
+and
+[`attribute.KeyValue`](https://pkg.go.dev/go.opentelemetry.io/otel/attribute#KeyValue)
+types.
+These types cover the Logs Data Model `any` value shape, including empty
+values, byte slices, generic slices, and maps.
+Reusing the attribute package keeps the API consistent across signals and
+avoids maintaining a second value model with conversion helpers.
+
+The zero value of `attribute.Value` represents an empty body.
+Log maps use `attribute.MAP`, which may contain duplicate keys when callers
+construct one that way. Duplicate-key normalization is an SDK policy, not an
+API behavior.
The caller must not subsequently mutate the record passed to `Emit`.
This would allow the implementation to not clone the record,
@@ -252,12 +223,11 @@ Rejected alternatives:
- [Passing record as pointer to Logger.Emit](#passing-record-as-pointer-to-loggeremit)
- [Logger.WithAttributes](#loggerwithattributes)
- [Record attributes as slice](#record-attributes-as-slice)
-- [Use any instead of defining Value](#use-any-instead-of-defining-value)
+- [Use any instead of attribute.Value](#use-any-instead-of-attributevalue)
- [Severity type encapsulating number and text](#severity-type-encapsulating-number-and-text)
-- [Reuse attribute package](#reuse-attribute-package)
+- [Define log-specific value types](#define-log-specific-value-types)
- [Mix receiver types for Record](#mix-receiver-types-for-record)
- [Add XYZ method to Logger](#add-xyz-method-to-logger)
-- [Rename KeyValue to Attr](#rename-keyvalue-to-attr)
### Logger.Enabled
@@ -476,30 +446,21 @@ less user friendly (users and bridges would use e.g. a `sync.Pool` to reduce
the number of heap allocation), less safe (more prone to use after free bugs
and race conditions), and the benchmark differences were not significant.
-### Use any instead of defining Value
+### Use any instead of attribute.Value
[Logs Data Model](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-body)
defines Body to be `any`.
One could propose to define `Body` (and attribute values) as `any`
-instead of a defining a new type (`Value`).
+instead of using `attribute.Value`.
First of all, [`any` type defined in the specification](https://opentelemetry.io/docs/specs/otel/logs/data-model/#type-any)
is not the same as `any` (`interface{}`) in Go.
Moreover, using `any` as a field would decrease the performance.[^7]
-Notice it will be still possible to add following kind and factories
-in a backwards compatible way:
-
-```go
-const KindMap Kind
-
-func AnyValue(value any) KeyValue
-
-func Any(key string, value any) KeyValue
-```
-
-However, currently, it would not be specification compliant.
+Using `attribute.Value` preserves a typed, allocation-conscious representation
+of the Logs Data Model `any` values while avoiding unconstrained `interface{}`
+handling in bridge implementations.
### Severity type encapsulating number and text
@@ -518,20 +479,22 @@ It should be more user friendly to have them separated.
Especially when having getter and setter methods, setting one value
when the other is already set would be unpleasant.
-### Reuse attribute package
+### Define log-specific value types
-It was tempting to reuse the existing
-[https://pkg.go.dev/go.opentelemetry.io/otel/attribute] package
-for defining log attributes and body.
+The original design defined `Kind`, `Value`, and `KeyValue` in
+`go.opentelemetry.io/otel/log`.
+That avoided coupling log bodies to the common attribute package while logs were
+still exploring structured value support.
-However, this would be wrong because [the log attribute definition](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-attributes)
-is different from [the common attribute definition](https://opentelemetry.io/docs/specs/otel/common/#attribute).
+The Logs Data Model and common attribute value model now share the structured
+`any` shapes needed by Go: empty, bool, int64, float64, string, byte slice,
+homogeneous slices, generic slices, and maps.
+The specification direction is to reuse these value shapes across signals.
+Keeping log-specific types would duplicate API surface, require conversion
+helpers, and make bridge code choose between two equivalent value models.
-Moreover, it there is nothing telling that [the body definition](https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-body)
-has anything in common with a common attribute value.
-
-Therefore, we define new types representing the abstract types defined
-in the [Logs Data Model](https://opentelemetry.io/docs/specs/otel/logs/data-model/#definitions-used-in-this-document).
+Therefore log records now use `attribute.Value` for body values and
+`attribute.KeyValue` for attributes and map entries.
### Mix receiver types for Record
@@ -591,36 +554,6 @@ The `Logger` does not have methods like `SetSeverity`, etc.
as the Logs API needs to follow (be compliant with)
the [specification](https://opentelemetry.io/docs/specs/otel/logs/api/)
-### Rename KeyValue to Attr
-
-There was a proposal to rename `KeyValue` to `Attr` (or `Attribute`).[^11]
-New developers may not intuitively know that `log.KeyValue` is an attribute in
-the OpenTelemetry parlance.
-
-During the discussion we agreed to keep the `KeyValue` name.
-
-The type is used in multiple semantics:
-
-- as a log attribute,
-- as a map item,
-- as a log record Body.
-
-As for map item semantics, this type is a key-value pair, not an attribute.
-Naming the type as `Attr` would convey semantical meaning
-that would not be correct for a map.
-
-We expect that most of the Logs API users will be OpenTelemetry contributors.
-We plan to implement bridges for the most popular logging libraries ourselves.
-Given we will all have the context needed to disambiguate these overlapping
-names, developers' confusion should not be an issue.
-
-For bridges not developed by us,
-developers will likely look at our existing bridges for inspiration.
-Our correct use of these types will be a reference to them.
-
-At last, we provide `ValueFromAttribute` and `KeyValueFromAttribute`
-to offer reuse of `attribute.Value` and `attribute.KeyValue`.
-
[^1]: [Handle structured body and attributes](https://github.com/pellared/opentelemetry-go/pull/7)
[^2]: Jonathan Amsterdam, [The Go Blog: Structured Logging with slog](https://go.dev/blog/slog)
[^3]: Jonathan Amsterdam, [GopherCon Europe 2023: A Fast Structured Logging Package](https://www.youtube.com/watch?v=tC4Jt3i62ns)
@@ -631,4 +564,3 @@ to offer reuse of `attribute.Value` and `attribute.KeyValue`.
[^8]: [log/slog: structured, leveled logging](https://github.com/golang/go/issues/56345#issuecomment-1302563756)
[^9]: [Record with pointer receivers only](https://github.com/pellared/opentelemetry-go/pull/8)
[^10]: [Go FAQ: Stack or heap](https://go.dev/doc/faq#stack_or_heap)
-[^11]: [Rename KeyValue to Attr discussion](https://github.com/open-telemetry/opentelemetry-go/pull/4809#discussion_r1476080093)
diff --git a/vendor/go.opentelemetry.io/otel/log/doc.go b/vendor/go.opentelemetry.io/otel/log/doc.go
index b7a085c63..c6f956269 100644
--- a/vendor/go.opentelemetry.io/otel/log/doc.go
+++ b/vendor/go.opentelemetry.io/otel/log/doc.go
@@ -82,4 +82,4 @@ implement all the API interfaces when a user updates their API.
[registry]: https://opentelemetry.io/ecosystem/registry/?language=go&component=log-bridge
*/
-package log // import "go.opentelemetry.io/otel/log"
+package log
diff --git a/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go b/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go
index 9b401b2b1..70bab2312 100644
--- a/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go
+++ b/vendor/go.opentelemetry.io/otel/log/embedded/embedded.go
@@ -11,7 +11,7 @@
// bump of the API package).
//
// [OpenTelemetry Logs API]: https://pkg.go.dev/go.opentelemetry.io/otel/log
-package embedded // import "go.opentelemetry.io/otel/log/embedded"
+package embedded
// LoggerProvider is embedded in the [Logs API LoggerProvider].
//
diff --git a/vendor/go.opentelemetry.io/otel/log/global/log.go b/vendor/go.opentelemetry.io/otel/log/global/log.go
index bfdb18479..ac9957c3f 100644
--- a/vendor/go.opentelemetry.io/otel/log/global/log.go
+++ b/vendor/go.opentelemetry.io/otel/log/global/log.go
@@ -9,7 +9,7 @@ This package is experimental. It will be deprecated and removed when the [log]
package becomes stable. Its functionality will be migrated to
go.opentelemetry.io/otel.
*/
-package global // import "go.opentelemetry.io/otel/log/global"
+package global
import (
"go.opentelemetry.io/otel/log"
diff --git a/vendor/go.opentelemetry.io/otel/log/internal/global/log.go b/vendor/go.opentelemetry.io/otel/log/internal/global/log.go
index e463acbf1..14eadf2e3 100644
--- a/vendor/go.opentelemetry.io/otel/log/internal/global/log.go
+++ b/vendor/go.opentelemetry.io/otel/log/internal/global/log.go
@@ -3,7 +3,7 @@
// Package global is the internal implementation of the OpenTelemetry global
// Logs API.
-package global // import "go.opentelemetry.io/otel/log/internal/global"
+package global
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/log/internal/global/state.go b/vendor/go.opentelemetry.io/otel/log/internal/global/state.go
index dbe1c2fbf..e872cc2a8 100644
--- a/vendor/go.opentelemetry.io/otel/log/internal/global/state.go
+++ b/vendor/go.opentelemetry.io/otel/log/internal/global/state.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package global // import "go.opentelemetry.io/otel/log/internal/global"
+package global
import (
"errors"
diff --git a/vendor/go.opentelemetry.io/otel/log/keyvalue.go b/vendor/go.opentelemetry.io/otel/log/keyvalue.go
deleted file mode 100644
index ebf4fcbee..000000000
--- a/vendor/go.opentelemetry.io/otel/log/keyvalue.go
+++ /dev/null
@@ -1,453 +0,0 @@
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-//go:generate stringer -type=Kind -trimprefix=Kind
-
-package log // import "go.opentelemetry.io/otel/log"
-
-import (
- "bytes"
- "cmp"
- "errors"
- "fmt"
- "math"
- "slices"
- "strconv"
- "unsafe"
-
- "go.opentelemetry.io/otel/attribute"
- "go.opentelemetry.io/otel/internal/global"
-)
-
-// errKind is logged when a Value is decoded to an incompatible type.
-var errKind = errors.New("invalid Kind")
-
-// Kind is the kind of a [Value].
-type Kind int
-
-// Kind values.
-const (
- KindEmpty Kind = iota
- KindBool
- KindFloat64
- KindInt64
- KindString
- KindBytes
- KindSlice
- KindMap
-)
-
-// A Value represents a structured log value.
-// A zero value is valid and represents an empty value.
-type Value struct {
- // Ensure forward compatibility by explicitly making this not comparable.
- noCmp [0]func() //nolint: unused // This is indeed used.
-
- // num holds the value for Int64, Float64, and Bool. It holds the length
- // for String, Bytes, Slice, Map.
- num uint64
- // any holds either the KindBool, KindInt64, KindFloat64, stringptr,
- // bytesptr, sliceptr, or mapptr. If KindBool, KindInt64, or KindFloat64
- // then the value of Value is in num as described above. Otherwise, it
- // contains the value wrapped in the appropriate type.
- any any
-}
-
-type (
- // sliceptr represents a value in Value.any for KindString Values.
- stringptr *byte
- // bytesptr represents a value in Value.any for KindBytes Values.
- bytesptr *byte
- // sliceptr represents a value in Value.any for KindSlice Values.
- sliceptr *Value
- // mapptr represents a value in Value.any for KindMap Values.
- mapptr *KeyValue
-)
-
-// StringValue returns a new [Value] for a string.
-func StringValue(v string) Value {
- return Value{
- num: uint64(len(v)),
- any: stringptr(unsafe.StringData(v)),
- }
-}
-
-// IntValue returns a [Value] for an int.
-func IntValue(v int) Value { return Int64Value(int64(v)) }
-
-// Int64Value returns a [Value] for an int64.
-func Int64Value(v int64) Value {
- // This can be later converted back to int64 (overflow not checked).
- return Value{num: uint64(v), any: KindInt64} // nolint:gosec
-}
-
-// Float64Value returns a [Value] for a float64.
-func Float64Value(v float64) Value {
- return Value{num: math.Float64bits(v), any: KindFloat64}
-}
-
-// BoolValue returns a [Value] for a bool.
-func BoolValue(v bool) Value { //nolint:revive // Not a control flag.
- var n uint64
- if v {
- n = 1
- }
- return Value{num: n, any: KindBool}
-}
-
-// BytesValue returns a [Value] for a byte slice. The passed slice must not be
-// changed after it is passed.
-func BytesValue(v []byte) Value {
- return Value{
- num: uint64(len(v)),
- any: bytesptr(unsafe.SliceData(v)),
- }
-}
-
-// SliceValue returns a [Value] for a slice of [Value]. The passed slice must
-// not be changed after it is passed.
-func SliceValue(vs ...Value) Value {
- return Value{
- num: uint64(len(vs)),
- any: sliceptr(unsafe.SliceData(vs)),
- }
-}
-
-// MapValue returns a new [Value] for a slice of key-value pairs. The passed
-// slice must not be changed after it is passed.
-func MapValue(kvs ...KeyValue) Value {
- return Value{
- num: uint64(len(kvs)),
- any: mapptr(unsafe.SliceData(kvs)),
- }
-}
-
-// AsString returns the value held by v as a string.
-func (v Value) AsString() string {
- if sp, ok := v.any.(stringptr); ok {
- return unsafe.String(sp, v.num)
- }
- global.Error(errKind, "AsString", "Kind", v.Kind())
- return ""
-}
-
-// asString returns the value held by v as a string. It will panic if the Value
-// is not KindString.
-func (v Value) asString() string {
- return unsafe.String(v.any.(stringptr), v.num)
-}
-
-// AsInt64 returns the value held by v as an int64.
-func (v Value) AsInt64() int64 {
- if v.Kind() != KindInt64 {
- global.Error(errKind, "AsInt64", "Kind", v.Kind())
- return 0
- }
- return v.asInt64()
-}
-
-// asInt64 returns the value held by v as an int64. If v is not of KindInt64,
-// this will return garbage.
-func (v Value) asInt64() int64 {
- // Assumes v.num was a valid int64 (overflow not checked).
- return int64(v.num) // nolint: gosec
-}
-
-// AsBool returns the value held by v as a bool.
-func (v Value) AsBool() bool {
- if v.Kind() != KindBool {
- global.Error(errKind, "AsBool", "Kind", v.Kind())
- return false
- }
- return v.asBool()
-}
-
-// asBool returns the value held by v as a bool. If v is not of KindBool, this
-// will return garbage.
-func (v Value) asBool() bool { return v.num == 1 }
-
-// AsFloat64 returns the value held by v as a float64.
-func (v Value) AsFloat64() float64 {
- if v.Kind() != KindFloat64 {
- global.Error(errKind, "AsFloat64", "Kind", v.Kind())
- return 0
- }
- return v.asFloat64()
-}
-
-// asFloat64 returns the value held by v as a float64. If v is not of
-// KindFloat64, this will return garbage.
-func (v Value) asFloat64() float64 { return math.Float64frombits(v.num) }
-
-// AsBytes returns the value held by v as a []byte.
-func (v Value) AsBytes() []byte {
- if sp, ok := v.any.(bytesptr); ok {
- return unsafe.Slice((*byte)(sp), v.num)
- }
- global.Error(errKind, "AsBytes", "Kind", v.Kind())
- return nil
-}
-
-// asBytes returns the value held by v as a []byte. It will panic if the Value
-// is not KindBytes.
-func (v Value) asBytes() []byte {
- return unsafe.Slice((*byte)(v.any.(bytesptr)), v.num)
-}
-
-// AsSlice returns the value held by v as a []Value.
-func (v Value) AsSlice() []Value {
- if sp, ok := v.any.(sliceptr); ok {
- return unsafe.Slice((*Value)(sp), v.num)
- }
- global.Error(errKind, "AsSlice", "Kind", v.Kind())
- return nil
-}
-
-// asSlice returns the value held by v as a []Value. It will panic if the Value
-// is not KindSlice.
-func (v Value) asSlice() []Value {
- return unsafe.Slice((*Value)(v.any.(sliceptr)), v.num)
-}
-
-// AsMap returns the value held by v as a []KeyValue.
-func (v Value) AsMap() []KeyValue {
- if sp, ok := v.any.(mapptr); ok {
- return unsafe.Slice((*KeyValue)(sp), v.num)
- }
- global.Error(errKind, "AsMap", "Kind", v.Kind())
- return nil
-}
-
-// asMap returns the value held by v as a []KeyValue. It will panic if the
-// Value is not KindMap.
-func (v Value) asMap() []KeyValue {
- return unsafe.Slice((*KeyValue)(v.any.(mapptr)), v.num)
-}
-
-// Kind returns the Kind of v.
-func (v Value) Kind() Kind {
- switch x := v.any.(type) {
- case Kind:
- return x
- case stringptr:
- return KindString
- case bytesptr:
- return KindBytes
- case sliceptr:
- return KindSlice
- case mapptr:
- return KindMap
- default:
- return KindEmpty
- }
-}
-
-// Empty reports whether v does not hold any value.
-func (v Value) Empty() bool { return v.Kind() == KindEmpty }
-
-// Equal reports whether v is equal to w.
-func (v Value) Equal(w Value) bool {
- k1 := v.Kind()
- k2 := w.Kind()
- if k1 != k2 {
- return false
- }
- switch k1 {
- case KindInt64, KindBool:
- return v.num == w.num
- case KindString:
- return v.asString() == w.asString()
- case KindFloat64:
- return v.asFloat64() == w.asFloat64()
- case KindSlice:
- return slices.EqualFunc(v.asSlice(), w.asSlice(), Value.Equal)
- case KindMap:
- sv := sortMap(v.asMap())
- sw := sortMap(w.asMap())
- return slices.EqualFunc(sv, sw, KeyValue.Equal)
- case KindBytes:
- return bytes.Equal(v.asBytes(), w.asBytes())
- case KindEmpty:
- return true
- default:
- global.Error(errKind, "Equal", "Kind", k1)
- return false
- }
-}
-
-func sortMap(m []KeyValue) []KeyValue {
- sm := make([]KeyValue, len(m))
- copy(sm, m)
- slices.SortFunc(sm, func(a, b KeyValue) int {
- return cmp.Compare(a.Key, b.Key)
- })
-
- return sm
-}
-
-// String returns Value's value as a string, formatted like [fmt.Sprint].
-//
-// The returned string is meant for debugging;
-// the string representation is not stable.
-func (v Value) String() string {
- switch v.Kind() {
- case KindString:
- return v.asString()
- case KindInt64:
- // Assumes v.num was a valid int64 (overflow not checked).
- return strconv.FormatInt(int64(v.num), 10) // nolint: gosec
- case KindFloat64:
- return strconv.FormatFloat(v.asFloat64(), 'g', -1, 64)
- case KindBool:
- return strconv.FormatBool(v.asBool())
- case KindBytes:
- return fmt.Sprint(v.asBytes()) // nolint:staticcheck // Use fmt.Sprint to encode as slice.
- case KindMap:
- return fmt.Sprint(v.asMap())
- case KindSlice:
- return fmt.Sprint(v.asSlice())
- case KindEmpty:
- return ""
- default:
- // Try to handle this as gracefully as possible.
- //
- // Don't panic here. The goal here is to have developers find this
- // first if a slog.Kind is is not handled. It is
- // preferable to have user's open issue asking why their attributes
- // have a "unhandled: " prefix than say that their code is panicking.
- return fmt.Sprintf("", v.Kind())
- }
-}
-
-// A KeyValue is a key-value pair used to represent a log attribute (a
-// superset of [go.opentelemetry.io/otel/attribute.KeyValue]) and map item.
-type KeyValue struct {
- Key string
- Value Value
-}
-
-// Equal reports whether a is equal to b.
-func (a KeyValue) Equal(b KeyValue) bool {
- return a.Key == b.Key && a.Value.Equal(b.Value)
-}
-
-// String returns a KeyValue for a string value.
-func String(key, value string) KeyValue {
- return KeyValue{key, StringValue(value)}
-}
-
-// Int64 returns a KeyValue for an int64 value.
-func Int64(key string, value int64) KeyValue {
- return KeyValue{key, Int64Value(value)}
-}
-
-// Int returns a KeyValue for an int value.
-func Int(key string, value int) KeyValue {
- return KeyValue{key, IntValue(value)}
-}
-
-// Float64 returns a KeyValue for a float64 value.
-func Float64(key string, value float64) KeyValue {
- return KeyValue{key, Float64Value(value)}
-}
-
-// Bool returns a KeyValue for a bool value.
-func Bool(key string, value bool) KeyValue {
- return KeyValue{key, BoolValue(value)}
-}
-
-// Bytes returns a KeyValue for a []byte value.
-// The passed slice must not be changed after it is passed.
-func Bytes(key string, value []byte) KeyValue {
- return KeyValue{key, BytesValue(value)}
-}
-
-// Slice returns a KeyValue for a []Value value.
-// The passed slice must not be changed after it is passed.
-func Slice(key string, value ...Value) KeyValue {
- return KeyValue{key, SliceValue(value...)}
-}
-
-// Map returns a KeyValue for a map value.
-// The passed slice must not be changed after it is passed.
-func Map(key string, value ...KeyValue) KeyValue {
- return KeyValue{key, MapValue(value...)}
-}
-
-// Empty returns a KeyValue with an empty value.
-func Empty(key string) KeyValue {
- return KeyValue{key, Value{}}
-}
-
-// String returns key-value pair as a string, formatted like "key:value".
-//
-// The returned string is meant for debugging;
-// the string representation is not stable.
-func (a KeyValue) String() string {
- return fmt.Sprintf("%s:%s", a.Key, a.Value)
-}
-
-// ValueFromAttribute converts [attribute.Value] to [Value].
-func ValueFromAttribute(value attribute.Value) Value {
- switch value.Type() {
- case attribute.EMPTY:
- return Value{}
- case attribute.BOOL:
- return BoolValue(value.AsBool())
- case attribute.BOOLSLICE:
- val := value.AsBoolSlice()
- res := make([]Value, 0, len(val))
- for _, v := range val {
- res = append(res, BoolValue(v))
- }
- return SliceValue(res...)
- case attribute.INT64:
- return Int64Value(value.AsInt64())
- case attribute.INT64SLICE:
- val := value.AsInt64Slice()
- res := make([]Value, 0, len(val))
- for _, v := range val {
- res = append(res, Int64Value(v))
- }
- return SliceValue(res...)
- case attribute.FLOAT64:
- return Float64Value(value.AsFloat64())
- case attribute.FLOAT64SLICE:
- val := value.AsFloat64Slice()
- res := make([]Value, 0, len(val))
- for _, v := range val {
- res = append(res, Float64Value(v))
- }
- return SliceValue(res...)
- case attribute.STRING:
- return StringValue(value.AsString())
- case attribute.STRINGSLICE:
- val := value.AsStringSlice()
- res := make([]Value, 0, len(val))
- for _, v := range val {
- res = append(res, StringValue(v))
- }
- return SliceValue(res...)
- case attribute.BYTESLICE:
- val := value.AsByteSlice()
- return BytesValue(val)
- case attribute.SLICE:
- val := value.AsSlice()
- res := make([]Value, 0, len(val))
- for _, v := range val {
- res = append(res, ValueFromAttribute(v))
- }
- return SliceValue(res...)
- }
- // This code should never be reached
- // as log attributes are a superset of standard attributes.
- panic("unknown attribute type")
-}
-
-// KeyValueFromAttribute converts [attribute.KeyValue] to [KeyValue].
-func KeyValueFromAttribute(kv attribute.KeyValue) KeyValue {
- return KeyValue{
- Key: string(kv.Key),
- Value: ValueFromAttribute(kv.Value),
- }
-}
diff --git a/vendor/go.opentelemetry.io/otel/log/kind_string.go b/vendor/go.opentelemetry.io/otel/log/kind_string.go
deleted file mode 100644
index b4f9e5335..000000000
--- a/vendor/go.opentelemetry.io/otel/log/kind_string.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Code generated by "stringer -type=Kind -trimprefix=Kind"; DO NOT EDIT.
-
-package log
-
-import "strconv"
-
-func _() {
- // An "invalid array index" compiler error signifies that the constant values have changed.
- // Re-run the stringer command to generate them again.
- var x [1]struct{}
- _ = x[KindEmpty-0]
- _ = x[KindBool-1]
- _ = x[KindFloat64-2]
- _ = x[KindInt64-3]
- _ = x[KindString-4]
- _ = x[KindBytes-5]
- _ = x[KindSlice-6]
- _ = x[KindMap-7]
-}
-
-const _Kind_name = "EmptyBoolFloat64Int64StringBytesSliceMap"
-
-var _Kind_index = [...]uint8{0, 5, 9, 16, 21, 27, 32, 37, 40}
-
-func (i Kind) String() string {
- idx := int(i) - 0
- if i < 0 || idx >= len(_Kind_index)-1 {
- return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
- }
- return _Kind_name[_Kind_index[idx]:_Kind_index[idx+1]]
-}
diff --git a/vendor/go.opentelemetry.io/otel/log/logger.go b/vendor/go.opentelemetry.io/otel/log/logger.go
index 014161969..178e6be26 100644
--- a/vendor/go.opentelemetry.io/otel/log/logger.go
+++ b/vendor/go.opentelemetry.io/otel/log/logger.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/log"
+package log
import (
"context"
@@ -36,7 +36,8 @@ type Logger interface {
//
// This is useful for users that want to know if a [Record]
// will be processed or dropped before they perform complex operations to
- // construct the [Record].
+ // construct the [Record]. Callers should invoke Enabled before each call
+ // to [Logger.Emit] because the enabled state may change over time.
//
// The passed param is likely to be a partial record information being
// provided (e.g a param with only the Severity set).
diff --git a/vendor/go.opentelemetry.io/otel/log/noop/noop.go b/vendor/go.opentelemetry.io/otel/log/noop/noop.go
index d779e5d80..082eb887b 100644
--- a/vendor/go.opentelemetry.io/otel/log/noop/noop.go
+++ b/vendor/go.opentelemetry.io/otel/log/noop/noop.go
@@ -12,7 +12,7 @@
// defaults to no operation for methods it does not implement.
//
// [OpenTelemetry Logs API]: https://pkg.go.dev/go.opentelemetry.io/otel/log
-package noop // import "go.opentelemetry.io/otel/log/noop"
+package noop
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/log/provider.go b/vendor/go.opentelemetry.io/otel/log/provider.go
index 5c8ca328f..62b7d73fc 100644
--- a/vendor/go.opentelemetry.io/otel/log/provider.go
+++ b/vendor/go.opentelemetry.io/otel/log/provider.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/log"
+package log
import "go.opentelemetry.io/otel/log/embedded"
@@ -24,7 +24,8 @@ type LoggerProvider interface {
// commonly, this means a bridge will need to accept this value from its
// users.
//
- // If name is empty, implementations need to provide a default name.
+ // An empty name is invalid. Implementations should retain the empty value as the
+ // instrumentation scope name, return a working Logger, and report the invalid value.
//
// The version of the packages using a bridge can be critical information
// to include when logging. The bridge should accept this version
diff --git a/vendor/go.opentelemetry.io/otel/log/record.go b/vendor/go.opentelemetry.io/otel/log/record.go
index cf62deb9e..9e4e4d80b 100644
--- a/vendor/go.opentelemetry.io/otel/log/record.go
+++ b/vendor/go.opentelemetry.io/otel/log/record.go
@@ -1,11 +1,13 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/log"
+package log
import (
"slices"
"time"
+
+ "go.opentelemetry.io/otel/attribute"
)
// attributesInlineCount is the number of attributes that are efficiently
@@ -25,7 +27,7 @@ type Record struct {
observedTimestamp time.Time
severity Severity
severityText string
- body Value
+ body attribute.Value
err error
// The fields below are for optimizing the implementation of Attributes and
@@ -35,7 +37,7 @@ type Record struct {
// Allocation optimization: an inline array sized to hold
// the majority of log calls (based on examination of open-source
// code). It holds the start of the list of attributes.
- front [attributesInlineCount]KeyValue
+ front [attributesInlineCount]attribute.KeyValue
// The number of attributes in front.
nFront int
@@ -44,7 +46,7 @@ type Record struct {
// Invariants:
// - len(back) > 0 if nFront == len(front)
// - Unused array elements are zero-ed. Used to detect mistakes.
- back []KeyValue
+ back []attribute.KeyValue
}
// EventName returns the event name.
@@ -55,6 +57,7 @@ func (r *Record) EventName() string {
// SetEventName sets the event name.
// A log record with non-empty event name is interpreted as an event record.
+// Event names should uniquely identify the event's attribute and body structure.
func (r *Record) SetEventName(s string) {
r.eventName = s
}
@@ -102,12 +105,12 @@ func (r *Record) SetSeverityText(text string) {
}
// Body returns the body of the log record.
-func (r *Record) Body() Value {
+func (r *Record) Body() attribute.Value {
return r.body
}
// SetBody sets the body of the log record.
-func (r *Record) SetBody(v Value) {
+func (r *Record) SetBody(v attribute.Value) {
r.body = v
}
@@ -122,8 +125,8 @@ func (r *Record) SetErr(err error) {
}
// WalkAttributes walks all attributes the log record holds by calling f for
-// each on each [KeyValue] in the [Record]. Iteration stops if f returns false.
-func (r *Record) WalkAttributes(f func(KeyValue) bool) {
+// each on each [attribute.KeyValue] in the [Record]. Iteration stops if f returns false.
+func (r *Record) WalkAttributes(f func(attribute.KeyValue) bool) {
for i := 0; i < r.nFront; i++ {
if !f(r.front[i]) {
return
@@ -137,7 +140,7 @@ func (r *Record) WalkAttributes(f func(KeyValue) bool) {
}
// AddAttributes adds attributes to the log record.
-func (r *Record) AddAttributes(attrs ...KeyValue) {
+func (r *Record) AddAttributes(attrs ...attribute.KeyValue) {
var i int
for i = 0; i < len(attrs) && r.nFront < len(r.front); i++ {
a := attrs[i]
diff --git a/vendor/go.opentelemetry.io/otel/log/severity.go b/vendor/go.opentelemetry.io/otel/log/severity.go
index 0240fd5ac..29aed675d 100644
--- a/vendor/go.opentelemetry.io/otel/log/severity.go
+++ b/vendor/go.opentelemetry.io/otel/log/severity.go
@@ -3,7 +3,7 @@
//go:generate stringer -type=Severity -linecomment
-package log // import "go.opentelemetry.io/otel/log"
+package log
// Severity represents a log record severity (also known as log level). Smaller
// numerical values correspond to less severe log records (such as debug
diff --git a/vendor/go.opentelemetry.io/otel/metric.go b/vendor/go.opentelemetry.io/otel/metric.go
index 527d9aec8..30dbb4118 100644
--- a/vendor/go.opentelemetry.io/otel/metric.go
+++ b/vendor/go.opentelemetry.io/otel/metric.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
import (
"go.opentelemetry.io/otel/internal/global"
diff --git a/vendor/go.opentelemetry.io/otel/metric/asyncfloat64.go b/vendor/go.opentelemetry.io/otel/metric/asyncfloat64.go
index 1d21e2eb7..11e5b282f 100644
--- a/vendor/go.opentelemetry.io/otel/metric/asyncfloat64.go
+++ b/vendor/go.opentelemetry.io/otel/metric/asyncfloat64.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/metric/asyncint64.go b/vendor/go.opentelemetry.io/otel/metric/asyncint64.go
index 9d45a4d41..f5577b0c5 100644
--- a/vendor/go.opentelemetry.io/otel/metric/asyncint64.go
+++ b/vendor/go.opentelemetry.io/otel/metric/asyncint64.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/metric/config.go b/vendor/go.opentelemetry.io/otel/metric/config.go
index 889545e23..31a5da817 100644
--- a/vendor/go.opentelemetry.io/otel/metric/config.go
+++ b/vendor/go.opentelemetry.io/otel/metric/config.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"slices"
diff --git a/vendor/go.opentelemetry.io/otel/metric/doc.go b/vendor/go.opentelemetry.io/otel/metric/doc.go
index 794e1a8ba..235e81f3a 100644
--- a/vendor/go.opentelemetry.io/otel/metric/doc.go
+++ b/vendor/go.opentelemetry.io/otel/metric/doc.go
@@ -201,4 +201,4 @@ fully implement all the API interfaces when a user updates their API.
[OpenTelemetry documentation]: https://opentelemetry.io/docs/concepts/signals/metrics/
[GetMeterProvider]: https://pkg.go.dev/go.opentelemetry.io/otel#GetMeterProvider
*/
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
diff --git a/vendor/go.opentelemetry.io/otel/metric/embedded/embedded.go b/vendor/go.opentelemetry.io/otel/metric/embedded/embedded.go
index 1a9dc6809..10f361b5b 100644
--- a/vendor/go.opentelemetry.io/otel/metric/embedded/embedded.go
+++ b/vendor/go.opentelemetry.io/otel/metric/embedded/embedded.go
@@ -11,7 +11,7 @@
// the API package).
//
// [OpenTelemetry metric API]: https://pkg.go.dev/go.opentelemetry.io/otel/metric
-package embedded // import "go.opentelemetry.io/otel/metric/embedded"
+package embedded
// MeterProvider is embedded in
// [go.opentelemetry.io/otel/metric.MeterProvider].
diff --git a/vendor/go.opentelemetry.io/otel/metric/instrument.go b/vendor/go.opentelemetry.io/otel/metric/instrument.go
index 2e79ab568..e8c1c96cb 100644
--- a/vendor/go.opentelemetry.io/otel/metric/instrument.go
+++ b/vendor/go.opentelemetry.io/otel/metric/instrument.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/metric/meter.go b/vendor/go.opentelemetry.io/otel/metric/meter.go
index 5606ec4bd..70ff4c731 100644
--- a/vendor/go.opentelemetry.io/otel/metric/meter.go
+++ b/vendor/go.opentelemetry.io/otel/metric/meter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/metric/noop/noop.go b/vendor/go.opentelemetry.io/otel/metric/noop/noop.go
index 634e73aee..80c0f2f22 100644
--- a/vendor/go.opentelemetry.io/otel/metric/noop/noop.go
+++ b/vendor/go.opentelemetry.io/otel/metric/noop/noop.go
@@ -10,7 +10,7 @@
// This implementation can be embedded in other implementations of the
// OpenTelemetry metric API. Doing so will mean the implementation defaults to
// no operation for methods it does not implement.
-package noop // import "go.opentelemetry.io/otel/metric/noop"
+package noop
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/metric/syncfloat64.go b/vendor/go.opentelemetry.io/otel/metric/syncfloat64.go
index 2101f686a..2770ac2dc 100644
--- a/vendor/go.opentelemetry.io/otel/metric/syncfloat64.go
+++ b/vendor/go.opentelemetry.io/otel/metric/syncfloat64.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"context"
@@ -158,6 +158,8 @@ type Float64Histogram interface {
// Record adds an additional value to the distribution.
//
+ // The incr value is expected to be non-negative.
+ //
// Use the WithAttributeSet (or, if performance is not a concern,
// the WithAttributes) option to include measurement attributes.
//
diff --git a/vendor/go.opentelemetry.io/otel/metric/syncint64.go b/vendor/go.opentelemetry.io/otel/metric/syncint64.go
index 425c1a0d5..c8a739c90 100644
--- a/vendor/go.opentelemetry.io/otel/metric/syncint64.go
+++ b/vendor/go.opentelemetry.io/otel/metric/syncint64.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package metric // import "go.opentelemetry.io/otel/metric"
+package metric
import (
"context"
@@ -158,6 +158,8 @@ type Int64Histogram interface {
// Record adds an additional value to the distribution.
//
+ // The incr value is expected to be non-negative.
+ //
// Use the WithAttributeSet (or, if performance is not a concern,
// the WithAttributes) option to include measurement attributes.
//
diff --git a/vendor/go.opentelemetry.io/otel/propagation.go b/vendor/go.opentelemetry.io/otel/propagation.go
index 2fd949733..05e9b11ce 100644
--- a/vendor/go.opentelemetry.io/otel/propagation.go
+++ b/vendor/go.opentelemetry.io/otel/propagation.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
import (
"go.opentelemetry.io/otel/internal/global"
diff --git a/vendor/go.opentelemetry.io/otel/propagation/baggage.go b/vendor/go.opentelemetry.io/otel/propagation/baggage.go
index d81b709a2..9d7ef7c89 100644
--- a/vendor/go.opentelemetry.io/otel/propagation/baggage.go
+++ b/vendor/go.opentelemetry.io/otel/propagation/baggage.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package propagation // import "go.opentelemetry.io/otel/propagation"
+package propagation
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/propagation/doc.go b/vendor/go.opentelemetry.io/otel/propagation/doc.go
index 33a3baf15..6e2bbbb18 100644
--- a/vendor/go.opentelemetry.io/otel/propagation/doc.go
+++ b/vendor/go.opentelemetry.io/otel/propagation/doc.go
@@ -10,4 +10,4 @@ package is the W3C Trace Context encoding
(https://www.w3.org/TR/trace-context/), and W3C Baggage
(https://www.w3.org/TR/baggage/).
*/
-package propagation // import "go.opentelemetry.io/otel/propagation"
+package propagation
diff --git a/vendor/go.opentelemetry.io/otel/propagation/propagation.go b/vendor/go.opentelemetry.io/otel/propagation/propagation.go
index 0a32c59aa..a3891fbe7 100644
--- a/vendor/go.opentelemetry.io/otel/propagation/propagation.go
+++ b/vendor/go.opentelemetry.io/otel/propagation/propagation.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package propagation // import "go.opentelemetry.io/otel/propagation"
+package propagation
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/propagation/trace_context.go b/vendor/go.opentelemetry.io/otel/propagation/trace_context.go
index 11f404deb..ffaa90303 100644
--- a/vendor/go.opentelemetry.io/otel/propagation/trace_context.go
+++ b/vendor/go.opentelemetry.io/otel/propagation/trace_context.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package propagation // import "go.opentelemetry.io/otel/propagation"
+package propagation
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/requirements.txt b/vendor/go.opentelemetry.io/otel/requirements.txt
index 7c541dee7..b2666ab48 100644
--- a/vendor/go.opentelemetry.io/otel/requirements.txt
+++ b/vendor/go.opentelemetry.io/otel/requirements.txt
@@ -1 +1 @@
-codespell==2.4.2
+codespell==2.4.3
diff --git a/vendor/go.opentelemetry.io/otel/sdk/instrumentation/doc.go b/vendor/go.opentelemetry.io/otel/sdk/instrumentation/doc.go
index a4faa6a03..39b34eabe 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/instrumentation/doc.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/instrumentation/doc.go
@@ -10,4 +10,4 @@
// and
// https://github.com/open-telemetry/oteps/blob/d226b677d73a785523fe9b9701be13225ebc528d/text/0201-scope-attributes.md
// for more information.
-package instrumentation // import "go.opentelemetry.io/otel/sdk/instrumentation"
+package instrumentation
diff --git a/vendor/go.opentelemetry.io/otel/sdk/instrumentation/library.go b/vendor/go.opentelemetry.io/otel/sdk/instrumentation/library.go
index f2cdf3c65..8baf8dbb3 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/instrumentation/library.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/instrumentation/library.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package instrumentation // import "go.opentelemetry.io/otel/sdk/instrumentation"
+package instrumentation
// Library represents the instrumentation library.
//
diff --git a/vendor/go.opentelemetry.io/otel/sdk/instrumentation/scope.go b/vendor/go.opentelemetry.io/otel/sdk/instrumentation/scope.go
index 34852a47b..1fd06db75 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/instrumentation/scope.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/instrumentation/scope.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package instrumentation // import "go.opentelemetry.io/otel/sdk/instrumentation"
+package instrumentation
import "go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/internal/attrnorm/dedup.go b/vendor/go.opentelemetry.io/otel/sdk/internal/attrnorm/dedup.go
new file mode 100644
index 000000000..fe9ddc96d
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/sdk/internal/attrnorm/dedup.go
@@ -0,0 +1,300 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/attrnorm/dedup.go.tmpl
+
+// Package attrnorm normalizes attribute values.
+package attrnorm
+
+import (
+ "reflect"
+ "unsafe"
+
+ "go.opentelemetry.io/otel/attribute"
+)
+
+var (
+ keyValueType = reflect.TypeFor[attribute.KeyValue]()
+ valueType = reflect.TypeFor[attribute.Value]()
+)
+
+// rawValue mirrors attribute.Value. It is used only to read immutable slice
+// storage without calling AsMap or AsSlice on no-op paths.
+type rawValue struct {
+ vtype attribute.Type
+ numeric uint64
+ stringly string
+ slice any
+}
+
+// Value returns value with all map values deduplicated and whether it changed.
+//
+// Duplicate map keys are resolved using last-value-wins semantics.
+func Value(value attribute.Value) (attribute.Value, bool) {
+ switch value.Type() {
+ case attribute.SLICE:
+ return deduplicateSliceValue(value)
+ case attribute.MAP:
+ return deduplicateMapValue(value)
+ default:
+ return value, false
+ }
+}
+
+// KeyValue returns kv with all map values deduplicated and whether it changed.
+func KeyValue(kv attribute.KeyValue) (attribute.KeyValue, bool) {
+ value, changed := Value(kv.Value)
+ if changed {
+ kv.Value = value
+ }
+ return kv, changed
+}
+
+// KeyValues returns kvs with all map values deduplicated and whether they changed.
+//
+// The returned slice is the original kvs slice if no value needs
+// deduplication. Top-level keys in kvs are not deduplicated.
+func KeyValues(kvs []attribute.KeyValue) ([]attribute.KeyValue, bool) {
+ // Preserve the caller's slice on the common no-op path. Once a changed
+ // value is found, copy the prior values exactly once and fill the rest in
+ // place as the scan continues.
+ var normalized []attribute.KeyValue
+ for i, kv := range kvs {
+ kv, changed := KeyValue(kv)
+ if normalized != nil {
+ normalized[i] = kv
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ normalized = make([]attribute.KeyValue, len(kvs))
+ copy(normalized, kvs[:i])
+ normalized[i] = kv
+ }
+ if normalized == nil {
+ return kvs, false
+ }
+ return normalized, true
+}
+
+// Set returns set with all map values deduplicated and whether it changed.
+//
+// The returned Set is the original set if no value needs deduplication.
+// Top-level key uniqueness remains attribute.Set's responsibility; this only
+// normalizes map attribute values.
+func Set(set attribute.Set) (attribute.Set, bool) {
+ if set.Len() == 0 {
+ return set, false
+ }
+
+ // Most attribute sets contain no duplicate map keys. Delay allocation until
+ // the first changed value so the no-op path returns the original Set.
+ var normalized []attribute.KeyValue
+ for i := range set.Len() {
+ kv, _ := set.Get(i)
+ kv, changed := KeyValue(kv)
+ if normalized != nil {
+ normalized = append(normalized, kv)
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ normalized = make([]attribute.KeyValue, 0, set.Len())
+ for j := range i {
+ prior, _ := set.Get(j)
+ normalized = append(normalized, prior)
+ }
+ normalized = append(normalized, kv)
+ }
+ if normalized == nil {
+ return set, false
+ }
+
+ return attribute.NewSet(normalized...), true
+}
+
+func deduplicateSliceValue(value attribute.Value) (attribute.Value, bool) {
+ storage := valueStorage(value)
+ length := valueLen(storage)
+
+ // Slice values can contain map values, so recurse into each element while
+ // keeping the original attribute.Value when no element changes.
+ var normalized []attribute.Value
+ for i := range length {
+ elem := valueAt(storage, i)
+ elem, changed := Value(elem)
+ if normalized != nil {
+ normalized[i] = elem
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ normalized = make([]attribute.Value, length)
+ for j := range i {
+ normalized[j] = valueAt(storage, j)
+ }
+ normalized[i] = elem
+ }
+ if normalized == nil {
+ return value, false
+ }
+ return attribute.SliceValue(normalized...), true
+}
+
+func deduplicateMapValue(value attribute.Value) (attribute.Value, bool) {
+ storage := valueStorage(value)
+ length := keyValueLen(storage)
+ if length <= 1 {
+ // A single map entry cannot duplicate its own key, but its value might
+ // contain a map or slice that needs recursive normalization.
+ if length == 1 {
+ kv, changed := KeyValue(keyValueAt(storage, 0))
+ if changed {
+ return attribute.MapValue(kv), true
+ }
+ }
+ return value, false
+ }
+
+ var normalized []attribute.KeyValue
+ for i := 0; i < length; {
+ // attribute.MapValue stores key-values sorted by key using a stable
+ // sort. Equal keys therefore form a contiguous run, and the last
+ // element in that run is the last value provided by the caller.
+ first := keyValueAt(storage, i)
+ j := i + 1
+ for j < length && keyValueAt(storage, j).Key == first.Key {
+ j++
+ }
+
+ kv, nestedChanged := KeyValue(keyValueAt(storage, j-1))
+ // j-i > 1 means the current key run contained duplicates.
+ changed := nestedChanged || j-i > 1
+ if normalized != nil {
+ normalized = append(normalized, kv)
+ } else if changed {
+ normalized = make([]attribute.KeyValue, 0, length)
+ for k := range i {
+ normalized = append(normalized, keyValueAt(storage, k))
+ }
+ normalized = append(normalized, kv)
+ }
+ i = j
+ }
+ if normalized == nil {
+ return value, false
+ }
+ return attribute.MapValue(normalized...), true
+}
+
+func valueStorage(value attribute.Value) any {
+ // attribute.Value does not expose allocation-free map/slice iteration.
+ // The raw mirror lets us read the immutable backing array directly and
+ // reserve AsMap/AsSlice-style allocation for paths that actually change.
+ return (*rawValue)(
+ unsafe.Pointer(&value),
+ ).slice //nolint:gosec // Read-only mirror of attribute.Value for allocation-free iteration.
+}
+
+func valueLen(storage any) int {
+ // attribute.Value stores small slices in fixed-size array values. Handle
+ // the common sizes directly and fall back to reflection for larger arrays.
+ switch storage.(type) {
+ case [0]attribute.Value:
+ return 0
+ case [1]attribute.Value:
+ return 1
+ case [2]attribute.Value:
+ return 2
+ case [3]attribute.Value:
+ return 3
+ case [4]attribute.Value:
+ return 4
+ case [5]attribute.Value:
+ return 5
+ default:
+ return arrayLen(storage, valueType)
+ }
+}
+
+func valueAt(storage any, i int) attribute.Value {
+ switch values := storage.(type) {
+ case [1]attribute.Value:
+ return values[i]
+ case [2]attribute.Value:
+ return values[i]
+ case [3]attribute.Value:
+ return values[i]
+ case [4]attribute.Value:
+ return values[i]
+ case [5]attribute.Value:
+ return values[i]
+ default:
+ return arrayAt[attribute.Value](storage, valueType, i)
+ }
+}
+
+func keyValueLen(storage any) int {
+ // attribute.Value stores small maps in fixed-size key-value arrays. Handle
+ // the common sizes directly and fall back to reflection for larger arrays.
+ switch storage.(type) {
+ case [0]attribute.KeyValue:
+ return 0
+ case [1]attribute.KeyValue:
+ return 1
+ case [2]attribute.KeyValue:
+ return 2
+ case [3]attribute.KeyValue:
+ return 3
+ case [4]attribute.KeyValue:
+ return 4
+ case [5]attribute.KeyValue:
+ return 5
+ default:
+ return arrayLen(storage, keyValueType)
+ }
+}
+
+func keyValueAt(storage any, i int) attribute.KeyValue {
+ switch kvs := storage.(type) {
+ case [1]attribute.KeyValue:
+ return kvs[i]
+ case [2]attribute.KeyValue:
+ return kvs[i]
+ case [3]attribute.KeyValue:
+ return kvs[i]
+ case [4]attribute.KeyValue:
+ return kvs[i]
+ case [5]attribute.KeyValue:
+ return kvs[i]
+ default:
+ return arrayAt[attribute.KeyValue](storage, keyValueType, i)
+ }
+}
+
+func arrayLen(storage any, elem reflect.Type) int {
+ // Be defensive around invalid or unexpected Value storage. Returning zero
+ // makes malformed storage a no-op instead of panicking in telemetry paths.
+ array := reflect.ValueOf(storage)
+ if array.Kind() != reflect.Array || array.Type().Elem() != elem {
+ return 0
+ }
+ return array.Len()
+}
+
+func arrayAt[T any](storage any, elem reflect.Type, i int) T {
+ // Match arrayLen's fail-closed behavior for unexpected storage.
+ array := reflect.ValueOf(storage)
+ if array.Kind() != reflect.Array || array.Type().Elem() != elem || i < 0 || i >= array.Len() {
+ var zero T
+ return zero
+ }
+ return array.Index(i).Interface().(T)
+}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/internal/attrnorm/truncate.go b/vendor/go.opentelemetry.io/otel/sdk/internal/attrnorm/truncate.go
new file mode 100644
index 000000000..9955e9072
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/sdk/internal/attrnorm/truncate.go
@@ -0,0 +1,232 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/attrnorm/truncate.go.tmpl
+
+package attrnorm
+
+import (
+ "slices"
+ "strings"
+ "unicode/utf8"
+
+ "go.opentelemetry.io/otel/attribute"
+)
+
+// Truncate returns a truncated version of attr. Only string, string slice,
+// byte slice, slice, and map attribute values are truncated. String values are
+// truncated to at most a length of limit. Each string slice value is truncated
+// in this fashion (the slice length itself is unaffected), and byte slice
+// values are truncated to at most limit bytes. For slice and map attribute
+// values, the limit is applied recursively to contained values.
+//
+// No truncation is performed for a negative limit.
+func Truncate(limit int, attr attribute.KeyValue) attribute.KeyValue {
+ if limit < 0 {
+ return attr
+ }
+ switch attr.Value.Type() {
+ case attribute.STRING:
+ v := attr.Value.AsString()
+ return attr.Key.String(truncate(limit, v))
+ case attribute.STRINGSLICE:
+ v := attr.Value.AsStringSlice()
+ for i := range v {
+ v[i] = truncate(limit, v[i])
+ }
+ return attr.Key.StringSlice(v)
+ case attribute.BYTESLICE:
+ v := attr.Value.AsString()
+ if len(v) > limit {
+ return attr.Key.ByteSlice([]byte(v[:limit]))
+ }
+ return attr
+ case attribute.SLICE:
+ v := attr.Value.AsSlice()
+ if !slices.ContainsFunc(v, func(e attribute.Value) bool { return needsTruncation(limit, e) }) {
+ return attr
+ }
+ newV := make([]attribute.Value, len(v))
+ for i, elem := range v {
+ newV[i] = TruncateValue(limit, elem)
+ }
+ return attr.Key.Slice(newV...)
+ case attribute.MAP:
+ v := attr.Value.AsMap()
+ if !slices.ContainsFunc(v, func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }) {
+ return attr
+ }
+ newV := make([]attribute.KeyValue, len(v))
+ for i, elem := range v {
+ elem.Value = TruncateValue(limit, elem.Value)
+ newV[i] = elem
+ }
+ return attr.Key.Map(newV...)
+ }
+ return attr
+}
+
+// TruncateValue returns a truncated version of v. Only string, string
+// slice, byte slice, and (recursively) slice and map values are modified.
+//
+// No truncation is performed for a negative limit.
+func TruncateValue(limit int, v attribute.Value) attribute.Value {
+ if limit < 0 {
+ return v
+ }
+
+ switch v.Type() {
+ case attribute.STRING:
+ return attribute.StringValue(truncate(limit, v.AsString()))
+ case attribute.STRINGSLICE:
+ ss := v.AsStringSlice()
+ for i := range ss {
+ ss[i] = truncate(limit, ss[i])
+ }
+ return attribute.StringSliceValue(ss)
+ case attribute.BYTESLICE:
+ // len(v.AsString()) is identical to len(v.AsByteSlice()) but
+ // avoids allocating the full slice before truncation.
+ s := v.AsString()
+ if limit >= 0 && len(s) > limit {
+ return attribute.ByteSliceValue([]byte(s[:limit]))
+ }
+ case attribute.SLICE:
+ sl := v.AsSlice()
+ if !slices.ContainsFunc(sl, func(e attribute.Value) bool { return needsTruncation(limit, e) }) {
+ return v
+ }
+ newSl := make([]attribute.Value, len(sl))
+ for i, elem := range sl {
+ newSl[i] = TruncateValue(limit, elem)
+ }
+ return attribute.SliceValue(newSl...)
+ case attribute.MAP:
+ m := v.AsMap()
+ if !slices.ContainsFunc(m, func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }) {
+ return v
+ }
+ newM := make([]attribute.KeyValue, len(m))
+ for i, elem := range m {
+ elem.Value = TruncateValue(limit, elem.Value)
+ newM[i] = elem
+ }
+ return attribute.MapValue(newM...)
+ }
+ return v
+}
+
+// stringNeedsTruncation reports whether s would be modified by truncate for the
+// given limit.
+func stringNeedsTruncation(limit int, s string) bool {
+ if limit < 0 || len(s) <= limit {
+ return false
+ }
+ return utf8.RuneCountInString(s) > limit || !utf8.ValidString(s)
+}
+
+// needsTruncation reports whether v would be modified by TruncateValue for the
+// given limit.
+func needsTruncation(limit int, v attribute.Value) bool {
+ switch v.Type() {
+ case attribute.STRING:
+ return stringNeedsTruncation(limit, v.AsString())
+ case attribute.BYTESLICE:
+ // len(v.AsString()) is identical to len(v.AsByteSlice()) but
+ // avoids memory allocation.
+ if limit >= 0 && len(v.AsString()) > limit {
+ return true
+ }
+ case attribute.STRINGSLICE:
+ for _, s := range v.AsStringSlice() {
+ if stringNeedsTruncation(limit, s) {
+ return true
+ }
+ }
+ case attribute.SLICE:
+ return slices.ContainsFunc(v.AsSlice(), func(e attribute.Value) bool { return needsTruncation(limit, e) })
+ case attribute.MAP:
+ return slices.ContainsFunc(
+ v.AsMap(),
+ func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) },
+ )
+ }
+ return false
+}
+
+// truncate returns a truncated version of s such that it contains less than
+// the limit number of characters. Truncation is applied by returning the limit
+// number of valid characters contained in s.
+//
+// If limit is negative, it returns the original string.
+//
+// UTF-8 is supported. When truncating, all invalid characters are dropped
+// before applying truncation.
+//
+// If s already contains less than the limit number of bytes, it is returned
+// unchanged. No invalid characters are removed.
+func truncate(limit int, s string) string {
+ // This prioritize performance in the following order based on the most
+ // common expected use-cases.
+ //
+ // - Short values less than the default limit (128).
+ // - Strings with valid encodings that exceed the limit.
+ // - No limit.
+ // - Strings with invalid encodings that exceed the limit.
+ if limit < 0 || len(s) <= limit {
+ return s
+ }
+
+ // Optimistically, assume all valid UTF-8.
+ var b strings.Builder
+ count := 0
+ for i, c := range s {
+ if c != utf8.RuneError {
+ count++
+ if count > limit {
+ return s[:i]
+ }
+ continue
+ }
+
+ _, size := utf8.DecodeRuneInString(s[i:])
+ if size == 1 {
+ // Invalid encoding.
+ b.Grow(len(s) - 1)
+ _, _ = b.WriteString(s[:i])
+ s = s[i:]
+ break
+ }
+ }
+
+ // Fast-path, no invalid input.
+ if b.Cap() == 0 {
+ return s
+ }
+
+ // Truncate while validating UTF-8.
+ for i := 0; i < len(s) && count < limit; {
+ c := s[i]
+ if c < utf8.RuneSelf {
+ // Optimization for single byte runes (common case).
+ _ = b.WriteByte(c)
+ i++
+ count++
+ continue
+ }
+
+ _, size := utf8.DecodeRuneInString(s[i:])
+ if size == 1 {
+ // We checked for all 1-byte runes above, this is a RuneError.
+ i++
+ continue
+ }
+
+ _, _ = b.WriteString(s[i : i+size])
+ i += size
+ count++
+ }
+
+ return b.String()
+}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/internal/x/features.go b/vendor/go.opentelemetry.io/otel/sdk/internal/x/features.go
index 694b64a31..13ff34b27 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/internal/x/features.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/internal/x/features.go
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// Package x documents experimental features for [go.opentelemetry.io/otel/sdk].
-package x // import "go.opentelemetry.io/otel/sdk/internal/x"
+package x
import "strings"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/internal/x/x.go b/vendor/go.opentelemetry.io/otel/sdk/internal/x/x.go
index 13347e560..e829d1794 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/internal/x/x.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/internal/x/x.go
@@ -1,11 +1,11 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/x/x.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/x/x.go.tmpl
+
// Package x documents experimental features for [go.opentelemetry.io/otel/sdk].
-package x // import "go.opentelemetry.io/otel/sdk/internal/x"
+package x
import (
"os"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md b/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md
index 2e0fb15e2..3858b85e6 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/DESIGN.md
@@ -80,7 +80,25 @@ is implemented as `SimpleProcessor` struct in [simple.go](simple.go).
The [Batching processor](https://opentelemetry.io/docs/specs/otel/logs/sdk/#batching-processor)
is implemented as `BatchProcessor` struct in [batch.go](batch.go).
-The `Batcher` can be also configured using the `OTEL_BLRP_*` environment variables as
+`OnEmit` clones accepted records into a bounded, drop-oldest queue. Once the
+queue reaches the batch size, it attempts a non-blocking, coalesced worker
+notification. It may briefly contend on the queue lock but never waits for
+exporter I/O. A single worker goroutine owns dequeueing, scheduled exports, and
+all exporter lifecycle calls, so exporter backpressure blocks the worker
+instead of causing repeated polling.
+
+`ForceFlush` is serialized through the worker. When the worker accepts a
+request, it drains the records then queued in batches no larger than the
+configured maximum and calls the exporter's `ForceFlush` while the request
+context remains valid. `Shutdown` first closes queue admission, drains accepted
+records, calls `ForceFlush` while its context remains valid, and always invokes
+the exporter's `Shutdown`. Cancellation stops additional drain chunks subject
+to the exporter honoring its context.
+
+`WithMaxQueueSize` bounds the pending-record queue; the worker additionally
+retains bounded batch scratch space and records currently being exported.
+
+The `BatchProcessor` can also be configured using the `OTEL_BLRP_*` environment variables as
[defined by the specification](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#batch-logrecord-processor).
### Exporter
@@ -106,8 +124,18 @@ is defined as `Record` struct in [record.go](record.go).
The `Record` is designed similarly to [`log.Record`](https://pkg.go.dev/go.opentelemetry.io/otel/log#Record)
in order to reduce the number of heap allocations when processing attributes.
-
-The SDK does not have have an additional definition of
+The log body and attributes use `attribute.Value` and `attribute.KeyValue`
+from `go.opentelemetry.io/otel/attribute`, matching the API representation and
+avoiding an SDK-specific value tree.
+
+Top-level duplicate attributes are handled with last-value-wins semantics
+unless `WithAllowKeyDuplication` is configured. Nested `attribute.MAP` values
+use the same semantics for duplicate map keys, including the body value, so
+exporters receive a canonical attribute tree by default. The attribute value
+length limit recursively truncates string, string slice, byte slice, slice, and
+map attribute values. The body is deduplicated but not truncated.
+
+The SDK does not have an additional definition of
[ReadableLogRecord](https://opentelemetry.io/docs/specs/otel/logs/sdk/#readablelogrecord)
as the specification does not say that the exporters must not be able to modify
the log records. It simply requires them to be able to read the log records.
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/batch.go b/vendor/go.opentelemetry.io/otel/sdk/log/batch.go
index a03248eba..c3c8237d8 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/batch.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/batch.go
@@ -1,17 +1,20 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
"errors"
- "slices"
+ "math"
"sync"
"sync/atomic"
"time"
+ "go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/internal/global"
+ "go.opentelemetry.io/otel/sdk/log/internal/counter"
+ "go.opentelemetry.io/otel/sdk/log/internal/observ"
)
const (
@@ -19,7 +22,6 @@ const (
dfltExpInterval = time.Second
dfltExpTimeout = 30 * time.Second
dfltExpMaxBatchSize = 512
- dfltExpBufferSize = 1
envarMaxQSize = "OTEL_BLRP_MAX_QUEUE_SIZE"
envarExpInterval = "OTEL_BLRP_SCHEDULE_DELAY"
@@ -35,82 +37,83 @@ var _ Processor = (*BatchProcessor)(nil)
// Use [NewBatchProcessor] to create a BatchProcessor. An empty BatchProcessor
// is shut down by default, no records will be batched or exported.
type BatchProcessor struct {
- // The BatchProcessor is designed to provide the highest throughput of
- // log records possible while being compatible with OpenTelemetry. The
- // entry point of log records is the OnEmit method. This method is designed
- // to receive records as fast as possible while still honoring shutdown
- // commands. All records received are enqueued to queue.
- //
- // In order to block OnEmit as little as possible, a separate "poll"
- // goroutine is spawned at the creation of a BatchProcessor. This
- // goroutine is responsible for batching the queue at regular polled
- // intervals, or when it is directly signaled to.
- //
- // To keep the polling goroutine from backing up, all batches it makes are
- // exported with a bufferedExporter. This exporter allows the poll
- // goroutine to enqueue an export payload that will be handled in a
- // separate goroutine dedicated to the export. This asynchronous behavior
- // allows the poll goroutine to maintain accurate interval polling.
- //
- // ___BatchProcessor____ __Poll Goroutine__ __Export Goroutine__
- // || || || || || ||
- // || ********** || || || || ********** ||
- // || Records=>* OnEmit * || || | - ticker || || * export * ||
- // || ********** || || | - trigger || || ********** ||
- // || || || || | || || || ||
- // || || || || | || || || ||
- // || __________\/___ || || |*********** || || ______/\_______ ||
- // || (____queue______)>=||=||===|* batch *===||=||=>[_export_buffer_] ||
- // || || || |*********** || || ||
- // ||_____________________|| ||__________________|| ||____________________||
- //
- //
- // The "release valve" in this processing is the record queue. This queue
- // is a ring buffer. It will overwrite the oldest records first when writes
- // to OnEmit are made faster than the queue can be flushed. If batches
- // cannot be flushed to the export buffer, the records will remain in the
- // queue.
-
- // exporter is the bufferedExporter all batches are exported with.
- exporter *bufferExporter
+ // A single goroutine owns dequeueing and all exporter calls. OnEmit only
+ // writes to the bounded queue and signals that goroutine. Consequently,
+ // exporter backpressure blocks the exporter goroutine instead of causing
+ // another goroutine to retry without making progress.
+ exporter Exporter
// q is the active queue of records that have not yet been exported.
q *queue
- // batchSize is the minimum number of records needed before an export is
- // triggered (unless the interval expires).
+ // batchSize is the maximum number of records in a scheduled export.
batchSize int
- // pollTrigger triggers the poll goroutine to flush a batch from the queue.
- // This is sent to when it is known that the queue contains at least one
- // complete batch.
- //
- // When a send is made to the channel, the poll loop will be reset after
- // the flush. If there is still enough records in the queue for another
- // batch the reset of the poll loop will automatically re-trigger itself.
- // There is no need for the original sender to monitor and resend.
- pollTrigger chan struct{}
- // pollKill kills the poll goroutine. This is only expected to be closed
- // once by the Shutdown method.
- pollKill chan struct{}
- // pollDone signals the poll goroutine has completed.
- pollDone chan struct{}
+ // exportTrigger is a coalesced signal that records are ready to export.
+ exportTrigger chan struct{}
+ // flush serializes ForceFlush requests through the worker.
+ flush chan batchProcessorRequest
+ // shutdown accepts the single Shutdown request. It is separate from flush
+ // so shutdown cannot be blocked behind concurrent ForceFlush callers.
+ shutdown chan batchProcessorRequest
+ // done is closed by the exporter goroutine after exporter shutdown.
+ done chan struct{}
// stopped holds the stopped state of the BatchProcessor.
stopped atomic.Bool
+ // inst is the instrumentation for observability (nil when disabled).
+ inst *observ.BLP
+
noCmp [0]func() //nolint: unused // This is indeed used.
}
+type batchProcessorRequest struct {
+ ctx context.Context
+ resp chan<- error
+}
+
+func (r batchProcessorRequest) respond(err error) {
+ r.resp <- err
+}
+
// NewBatchProcessor decorates the provided exporter
// so that the log records are batched before exporting.
//
-// All of the exporter's methods are called synchronously.
+// Calls to the exporter's Export, ForceFlush, and Shutdown methods are
+// synchronized and never invoked concurrently.
func NewBatchProcessor(exporter Exporter, opts ...BatchProcessorOption) *BatchProcessor {
cfg := newBatchConfig(opts)
if exporter == nil {
// Do not panic on nil export.
exporter = defaultNoopExporter
}
+
+ b := &BatchProcessor{
+ q: newQueue(cfg.maxQSize.Value),
+ batchSize: cfg.expMaxBatchSize.Value,
+ exportTrigger: make(chan struct{}, 1),
+ flush: make(chan batchProcessorRequest),
+ shutdown: make(chan batchProcessorRequest, 1),
+ done: make(chan struct{}),
+ }
+
+ var err error
+ b.inst, err = observ.NewBLP(
+ counter.NextExporterID(),
+ func() int64 { return int64(b.q.Len()) },
+ int64(cfg.maxQSize.Value),
+ )
+ if err != nil {
+ otel.Handle(err)
+ }
+
+ // Wrap exporter with metrics recording if observability is enabled.
+ // This must be the innermost wrapper (closest to user exporter) to record
+ // metrics just before calling the actual exporter.
+ if b.inst != nil {
+ exporter = newMetricsExporter(exporter, b.inst)
+ }
+
// Order is important here. Wrap the timeoutExporter with the chunkExporter
// to ensure each export completes in timeout (instead of all chunked
// exports).
@@ -119,69 +122,144 @@ func NewBatchProcessor(exporter Exporter, opts ...BatchProcessorOption) *BatchPr
// appropriately on export.
exporter = newChunkExporter(exporter, cfg.expMaxBatchSize.Value)
- b := &BatchProcessor{
- exporter: newBufferExporter(exporter, cfg.expBufferSize.Value),
-
- q: newQueue(cfg.maxQSize.Value),
- batchSize: cfg.expMaxBatchSize.Value,
- pollTrigger: make(chan struct{}, 1),
- pollKill: make(chan struct{}),
- }
- b.pollDone = b.poll(cfg.expInterval.Value)
+ b.exporter = exporter
+ b.process(cfg.expInterval.Value)
return b
}
-// poll spawns a goroutine to handle interval polling and batch exporting. The
-// returned done chan is closed when the spawned goroutine completes.
-func (b *BatchProcessor) poll(interval time.Duration) (done chan struct{}) {
- done = make(chan struct{})
-
- ticker := time.NewTicker(interval)
- // TODO: investigate using a sync.Pool instead of cloning.
- buf := make([]Record, b.batchSize)
+// process starts the goroutine that owns dequeueing and all exporter calls.
+func (b *BatchProcessor) process(interval time.Duration) {
go func() {
- defer close(done)
- defer ticker.Stop()
+ timer := time.NewTimer(interval)
+ defer timer.Stop()
+ // The worker owns and reuses buf. Exporters must not retain the slice
+ // passed to them, so it is safe to refill after Export returns.
+ buf := make([]Record, b.batchSize)
for {
+ // Probe shutdown by itself first. This makes an already queued terminal
+ // request win over every other ready case. Closing done before replying
+ // also means a successful Shutdown response observes a stopped worker.
select {
- case <-ticker.C:
- case <-b.pollTrigger:
- ticker.Reset(interval)
- case <-b.pollKill:
+ case req := <-b.shutdown:
+ err := b.shutdownExporter(req.ctx)
+ close(b.done)
+ req.respond(err)
return
+ default:
}
- if d := b.q.Dropped(); d > 0 {
- global.Warn("dropped log records", "dropped", d)
- }
-
- var qLen int
- // Don't copy data from queue unless exporter can accept more, it is very expensive.
- if b.exporter.Ready() {
- qLen = b.q.TryDequeue(buf, func(r []Record) bool {
- ok := b.exporter.EnqueueExport(r)
- if ok {
- buf = slices.Clone(buf)
- }
- return ok
- })
- } else {
- qLen = b.q.Len()
+ // With no queued shutdown, service a waiting ForceFlush before ordinary
+ // export wakes. The default keeps this priority check non-blocking.
+ // Shutdown remains selectable in case it arrived after the first probe.
+ select {
+ case req := <-b.shutdown:
+ err := b.shutdownExporter(req.ctx)
+ close(b.done)
+ req.respond(err)
+ return
+ case req := <-b.flush:
+ err := b.flushExporter(req.ctx)
+ req.respond(err)
+ continue
+ default:
}
- if qLen >= b.batchSize {
- // There is another full batch ready. Immediately trigger
- // another export attempt.
- select {
- case b.pollTrigger <- struct{}{}:
- default:
- // Another flush signal already received.
- }
+ // No lifecycle request was waiting, so block on the complete event set.
+ // Both timer and size-triggered exports start a new interval window.
+ select {
+ case req := <-b.shutdown:
+ err := b.shutdownExporter(req.ctx)
+ close(b.done)
+ req.respond(err)
+ return
+ case req := <-b.flush:
+ err := b.flushExporter(req.ctx)
+ req.respond(err)
+ case <-timer.C:
+ resetTimer(timer, interval)
+ b.exportBatch(buf)
+ case <-b.exportTrigger:
+ resetTimer(timer, interval)
+ b.exportBatch(buf)
}
}
}()
- return done
+}
+
+func resetTimer(timer *time.Timer, interval time.Duration) {
+ // Handle both GODEBUG=asynctimerchan=[0|1] properly.
+ if !timer.Stop() {
+ select {
+ case <-timer.C:
+ default:
+ }
+ }
+ timer.Reset(interval)
+}
+
+func (b *BatchProcessor) exportBatch(buf []Record) {
+ b.logDroppedRecords()
+ n, remaining := b.q.Dequeue(buf)
+ if n == 0 {
+ return
+ }
+
+ err := b.exporter.Export(context.Background(), buf[:n])
+ clear(buf[:n])
+ if err != nil {
+ otel.Handle(err)
+ }
+ if remaining >= b.batchSize {
+ b.triggerExport()
+ }
+}
+
+func (b *BatchProcessor) flushExporter(ctx context.Context) error {
+ if err := ctx.Err(); err != nil {
+ return err
+ }
+ b.logDroppedRecords()
+ records := b.q.Flush()
+ err := b.exporter.Export(ctx, records)
+ clear(records)
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return errors.Join(err, ctxErr)
+ }
+ return errors.Join(err, b.exporter.ForceFlush(ctx))
+}
+
+func (b *BatchProcessor) shutdownExporter(ctx context.Context) error {
+ b.logDroppedRecords()
+ records := b.q.Flush()
+ err := b.exporter.Export(ctx, records)
+ clear(records)
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ err = errors.Join(err, ctxErr)
+ } else {
+ err = errors.Join(err, b.exporter.ForceFlush(ctx))
+ }
+ err = errors.Join(err, b.exporter.Shutdown(ctx))
+ if b.inst != nil {
+ err = errors.Join(err, b.inst.Shutdown())
+ }
+ return err
+}
+
+func (b *BatchProcessor) logDroppedRecords() {
+ if d := b.q.Dropped(); d > 0 {
+ if b.inst != nil {
+ b.inst.ProcessedQueueFull(context.Background(), int64(min(math.MaxInt64, d))) // nolint:gosec
+ }
+ global.Warn("dropped log records", "dropped", d)
+ }
+}
+
+func (b *BatchProcessor) triggerExport() {
+ select {
+ case b.exportTrigger <- struct{}{}:
+ default:
+ }
}
// Enabled returns true, indicating this Processor will process all records.
@@ -196,43 +274,31 @@ func (b *BatchProcessor) OnEmit(_ context.Context, r *Record) error {
}
// The record is cloned so that changes done by subsequent processors
// are not going to lead to a data race.
- if n := b.q.Enqueue(r.Clone()); n >= b.batchSize {
- select {
- case b.pollTrigger <- struct{}{}:
- default:
- // Flush chan full. The poll goroutine will handle this by
- // re-sending any trigger until the queue has less than batchSize
- // records.
- }
+ if n, accepted := b.q.Enqueue(r.Clone()); accepted && n >= b.batchSize {
+ b.triggerExport()
}
return nil
}
-// Shutdown flushes queued log records and shuts down the decorated exporter.
+// Shutdown flushes queued log records and the decorated exporter before
+// shutting it down.
func (b *BatchProcessor) Shutdown(ctx context.Context) error {
if b.stopped.Swap(true) || b.q == nil {
return nil
}
- // Stop the poll goroutine.
- close(b.pollKill)
+ b.q.Close()
+ resp := make(chan error, 1)
+ b.shutdown <- batchProcessorRequest{ctx: ctx, resp: resp}
+ if err := ctx.Err(); err != nil {
+ return err
+ }
select {
- case <-b.pollDone:
+ case err := <-resp:
+ return err
case <-ctx.Done():
- // Out of time.
- return errors.Join(ctx.Err(), b.exporter.Shutdown(ctx))
+ return ctx.Err()
}
-
- // Flush remaining queued before exporter shutdown.
- err := b.exporter.Export(ctx, b.q.Flush())
- return errors.Join(err, b.exporter.Shutdown(ctx))
-}
-
-var errPartialFlush = errors.New("partial flush: export buffer full")
-
-// Used for testing.
-var ctxErr = func(ctx context.Context) error {
- return ctx.Err()
}
// ForceFlush flushes queued log records and flushes the decorated exporter.
@@ -240,27 +306,26 @@ func (b *BatchProcessor) ForceFlush(ctx context.Context) error {
if b.stopped.Load() || b.q == nil {
return nil
}
+ if err := ctx.Err(); err != nil {
+ return err
+ }
- buf := make([]Record, b.q.cap)
- notFlushed := func() bool {
- var flushed bool
- _ = b.q.TryDequeue(buf, func(r []Record) bool {
- flushed = b.exporter.EnqueueExport(r)
- return flushed
- })
- return !flushed
+ resp := make(chan error, 1)
+ req := batchProcessorRequest{ctx: ctx, resp: resp}
+ select {
+ case b.flush <- req:
+ case <-b.done:
+ return nil
+ case <-ctx.Done():
+ return ctx.Err()
}
- var err error
- // For as long as ctx allows, try to make a single flush of the queue.
- for notFlushed() {
- // Use ctxErr instead of calling ctx.Err directly so we can test
- // the partial error return.
- if e := ctxErr(ctx); e != nil {
- err = errors.Join(e, errPartialFlush)
- break
- }
+
+ select {
+ case err := <-resp:
+ return err
+ case <-ctx.Done():
+ return ctx.Err()
}
- return errors.Join(err, b.exporter.ForceFlush(ctx))
}
// queue holds a queue of logging records.
@@ -273,6 +338,7 @@ type queue struct {
dropped atomic.Uint64
cap, len int
read, write *ring
+ closed bool
}
func newQueue(size int) *queue {
@@ -302,10 +368,14 @@ func (q *queue) Dropped() uint64 {
//
// If enqueueing r will exceed the capacity of q, the oldest Record held in q
// will be dropped and r retained.
-func (q *queue) Enqueue(r Record) int {
+func (q *queue) Enqueue(r Record) (int, bool) {
q.Lock()
defer q.Unlock()
+ if q.closed {
+ return q.len, false
+ }
+
q.write.Value = r
q.write = q.write.Next()
@@ -316,35 +386,23 @@ func (q *queue) Enqueue(r Record) int {
q.read = q.read.Next()
q.dropped.Add(1)
}
- return q.len
+ return q.len, true
}
-// TryDequeue attempts to dequeue up to len(buf) Records. The available Records
-// will be assigned into buf and passed to write. If write fails, returning
-// false, the Records will not be removed from the queue. If write succeeds,
-// returning true, the dequeued Records are removed from the queue. The number
-// of Records remaining in the queue are returned.
-//
-// When write is called the lock of q is held. The write function must not call
-// other methods of this q that acquire the lock.
-func (q *queue) TryDequeue(buf []Record, write func([]Record) bool) int {
+// Dequeue removes up to len(buf) records from the queue and copies them into
+// buf. The number copied and the number remaining are returned.
+func (q *queue) Dequeue(buf []Record) (int, int) {
q.Lock()
defer q.Unlock()
- origRead := q.read
-
n := min(len(buf), q.len)
for i := range n {
buf[i] = q.read.Value // nolint:gosec // n is bounded by len(buf)
+ q.read.Value = Record{}
q.read = q.read.Next()
}
-
- if write(buf[:n]) {
- q.len -= n
- } else {
- q.read = origRead
- }
- return q.len
+ q.len -= n
+ return n, q.len
}
// Flush returns all the Records held in the queue and resets it to be
@@ -353,9 +411,22 @@ func (q *queue) Flush() []Record {
q.Lock()
defer q.Unlock()
+ return q.flush()
+}
+
+// Close stops the queue from accepting records.
+func (q *queue) Close() {
+ q.Lock()
+ defer q.Unlock()
+
+ q.closed = true
+}
+
+func (q *queue) flush() []Record {
out := make([]Record, q.len)
for i := range out {
out[i] = q.read.Value
+ q.read.Value = Record{}
q.read = q.read.Next()
}
q.len = 0
@@ -368,7 +439,6 @@ type batchConfig struct {
expInterval setting[time.Duration]
expTimeout setting[time.Duration]
expMaxBatchSize setting[int]
- expBufferSize setting[int]
}
func newBatchConfig(options []BatchProcessorOption) batchConfig {
@@ -399,14 +469,9 @@ func newBatchConfig(options []BatchProcessorOption) batchConfig {
clearLessThanOne[int](),
getenv[int](envarExpMaxBatchSize),
clearLessThanOne[int](), // nolint:gocritic // the function argument is duplicated on purpose
- clampMax[int](c.maxQSize.Value),
fallback[int](dfltExpMaxBatchSize),
+ clampMax[int](c.maxQSize.Value),
)
- c.expBufferSize = c.expBufferSize.Resolve(
- clearLessThanOne[int](),
- fallback[int](dfltExpBufferSize),
- )
-
return c
}
@@ -474,8 +539,9 @@ func WithExportTimeout(d time.Duration) BatchProcessorOption {
// and this option is not passed, that variable value will be used.
//
// By default, if an environment variable is not set, and this option is not
-// passed, 512 will be used.
+// passed, 512 or the maximum queue size, if smaller, will be used.
// The default value is also used when the provided value is less than one.
+// The effective batch size will not exceed the configured maximum queue size.
func WithExportMaxBatchSize(size int) BatchProcessorOption {
return batchOptionFunc(func(cfg batchConfig) batchConfig {
cfg.expMaxBatchSize = newSetting(size)
@@ -483,14 +549,13 @@ func WithExportMaxBatchSize(size int) BatchProcessorOption {
})
}
-// WithExportBufferSize sets the batch buffer size.
-// Batches will be temporarily kept in a memory buffer until they are exported.
+// WithExportBufferSize is retained for source compatibility and has no effect.
+// The processor no longer maintains a separately configurable export-request
+// buffer. [WithMaxQueueSize] bounds the pending-record queue.
//
-// By default, a value of 1 will be used.
-// The default value is also used when the provided value is less than one.
-func WithExportBufferSize(size int) BatchProcessorOption {
+// Deprecated: This option is no longer used.
+func WithExportBufferSize(_ int) BatchProcessorOption {
return batchOptionFunc(func(cfg batchConfig) batchConfig {
- cfg.expBufferSize = newSetting(size)
return cfg
})
}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/doc.go b/vendor/go.opentelemetry.io/otel/sdk/log/doc.go
index a27834a5b..5153a0e55 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/doc.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/doc.go
@@ -36,4 +36,4 @@ the experimental features.
See [go.opentelemetry.io/otel/log] for more information about
the OpenTelemetry Logs API.
*/
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go b/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go
index a9d3c439b..973ff91d7 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/exporter.go
@@ -1,17 +1,14 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
"errors"
- "fmt"
- "sync"
- "sync/atomic"
"time"
- "go.opentelemetry.io/otel"
+ "go.opentelemetry.io/otel/sdk/log/internal/observ"
)
// Exporter handles the delivery of log records to external receivers.
@@ -67,6 +64,11 @@ func (noopExporter) Shutdown(context.Context) error { return nil }
func (noopExporter) ForceFlush(context.Context) error { return nil }
+func shutdownExporter(ctx context.Context, exporter Exporter) error {
+ err := exporter.ForceFlush(ctx)
+ return errors.Join(err, exporter.Shutdown(ctx))
+}
+
// chunkExporter wraps an Exporter's Export method so it is called with
// appropriately sized export payloads. Any payload larger than a defined size
// is chunked into smaller payloads and exported sequentially.
@@ -90,12 +92,19 @@ func newChunkExporter(exporter Exporter, size int) Exporter {
// Export exports records in chunks no larger than c.size.
func (c chunkExporter) Export(ctx context.Context, records []Record) error {
n := len(records)
+ var errs []error
for i, j := 0, min(c.size, n); i < n; i, j = i+c.size, min(j+c.size, n) {
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return errors.Join(append(errs, ctxErr)...)
+ }
if err := c.Exporter.Export(ctx, records[i:j]); err != nil {
- return err
+ errs = append(errs, err)
+ }
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return errors.Join(append(errs, ctxErr)...)
}
}
- return nil
+ return errors.Join(errs...)
}
// timeoutExporter wraps an Exporter and ensures any call to Export will have a
@@ -126,201 +135,27 @@ func (e *timeoutExporter) Export(ctx context.Context, records []Record) error {
return e.Exporter.Export(ctx, records)
}
-// exportSync exports all data from input using exporter in a spawned
-// goroutine. The returned chan will be closed when the spawned goroutine
-// completes.
-func exportSync(input <-chan exportData, exporter Exporter) (done chan struct{}) {
- done = make(chan struct{})
- go func() {
- defer close(done)
- for data := range input {
- data.DoExport(exporter.Export)
- }
- }()
- return done
-}
-
-// exportData is data related to an export.
-type exportData struct {
- ctx context.Context
- records []Record
-
- // respCh is the channel any error returned from the export will be sent
- // on. If this is nil, and the export error is non-nil, the error will
- // passed to the OTel error handler.
- respCh chan<- error
-}
-
-// DoExport calls exportFn with the data contained in e. The error response
-// will be returned on e's respCh if not nil. The error will be handled by the
-// default OTel error handle if it is not nil and respCh is nil or full.
-func (e exportData) DoExport(exportFn func(context.Context, []Record) error) {
- if len(e.records) == 0 {
- e.respond(nil)
- return
- }
-
- e.respond(exportFn(e.ctx, e.records))
-}
-
-func (e exportData) respond(err error) {
- select {
- case e.respCh <- err:
- default:
- // e.respCh is nil or busy, default to otel.Handler.
- if err != nil {
- otel.Handle(err)
- }
- }
-}
-
-// bufferExporter provides asynchronous and synchronous export functionality by
-// buffering export requests.
-type bufferExporter struct {
+// metricsExporter wraps an Exporter to record log processing metrics
+// just before calling the wrapped exporter.
+type metricsExporter struct {
Exporter
-
- input chan exportData
- inputMu sync.Mutex
-
- done chan struct{}
- stopped atomic.Bool
+ inst *observ.BLP
}
-// newBufferExporter returns a new bufferExporter that wraps exporter. The
-// returned bufferExporter will buffer at most size number of export requests.
-// If size is less than 1, 1 will be used.
-func newBufferExporter(exporter Exporter, size int) *bufferExporter {
- if size < 1 {
- size = 1
- }
- input := make(chan exportData, size)
- return &bufferExporter{
+// newMetricsExporter creates a metricsExporter that wraps the given exporter.
+func newMetricsExporter(exporter Exporter, inst *observ.BLP) Exporter {
+ return &metricsExporter{
Exporter: exporter,
-
- input: input,
- done: exportSync(input, exporter),
- }
-}
-
-func (e *bufferExporter) Ready() bool {
- return len(e.input) != cap(e.input)
-}
-
-var errStopped = errors.New("exporter stopped")
-
-func (e *bufferExporter) enqueue(ctx context.Context, records []Record, rCh chan<- error) error {
- data := exportData{ctx, records, rCh}
-
- e.inputMu.Lock()
- defer e.inputMu.Unlock()
-
- // Check stopped before enqueueing now that e.inputMu is held. This
- // prevents sends on a closed chan when Shutdown is called concurrently.
- if e.stopped.Load() {
- return errStopped
- }
-
- select {
- case e.input <- data:
- case <-ctx.Done():
- return ctx.Err()
+ inst: inst,
}
- return nil
}
-// EnqueueExport enqueues an export of records in the context of ctx to be
-// performed asynchronously. This will return true if the records are
-// successfully enqueued (or the bufferExporter is shut down), false otherwise.
-//
-// The passed records are held after this call returns.
-func (e *bufferExporter) EnqueueExport(records []Record) bool {
- if len(records) == 0 {
- // Nothing to enqueue, do not waste input space.
- return true
- }
-
- data := exportData{ctx: context.Background(), records: records}
-
- e.inputMu.Lock()
- defer e.inputMu.Unlock()
-
- // Check stopped before enqueueing now that e.inputMu is held. This
- // prevents sends on a closed chan when Shutdown is called concurrently.
- if e.stopped.Load() {
- return true
- }
-
- select {
- case e.input <- data:
- return true
- default:
- return false
- }
-}
-
-// Export synchronously exports records in the context of ctx. This will not
-// return until the export has been completed.
-func (e *bufferExporter) Export(ctx context.Context, records []Record) error {
- if len(records) == 0 {
- return nil
- }
-
- resp := make(chan error, 1)
- err := e.enqueue(ctx, records, resp)
- if err != nil {
- if errors.Is(err, errStopped) {
- return nil
- }
- return fmt.Errorf("%w: dropping %d records", err, len(records))
+// Export records the number of log records as a metric then forwards
+// them to the wrapped Exporter. Error returned from wrapped exporter
+// is not considered as per specification (to be measured by exporter).
+func (e *metricsExporter) Export(ctx context.Context, records []Record) error {
+ if e.inst != nil {
+ e.inst.Processed(ctx, int64(len(records)))
}
-
- select {
- case err := <-resp:
- return err
- case <-ctx.Done():
- return ctx.Err()
- }
-}
-
-// ForceFlush flushes buffered exports. Any existing exports that is buffered
-// is flushed before this returns.
-func (e *bufferExporter) ForceFlush(ctx context.Context) error {
- resp := make(chan error, 1)
- err := e.enqueue(ctx, nil, resp)
- if err != nil {
- if errors.Is(err, errStopped) {
- return nil
- }
- return err
- }
-
- select {
- case <-resp:
- case <-ctx.Done():
- return ctx.Err()
- }
- return e.Exporter.ForceFlush(ctx)
-}
-
-// Shutdown shuts down e.
-//
-// Any buffered exports are flushed before this returns.
-//
-// All calls to EnqueueExport or Exporter will return nil without any export
-// after this is called.
-func (e *bufferExporter) Shutdown(ctx context.Context) error {
- if e.stopped.Swap(true) {
- return nil
- }
- e.inputMu.Lock()
- defer e.inputMu.Unlock()
-
- // No more sends will be made.
- close(e.input)
- select {
- case <-e.done:
- case <-ctx.Done():
- return errors.Join(ctx.Err(), e.Exporter.Shutdown(ctx))
- }
- return e.Exporter.Shutdown(ctx)
+ return e.Exporter.Export(ctx, records)
}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go b/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go
index 5e496f7e2..b6eec35b2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/instrumentation.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
@@ -11,8 +11,8 @@ import (
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/sdk"
"go.opentelemetry.io/otel/sdk/log/internal/x"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
// newRecordCounterIncr returns a function that increments the log record
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/dedup.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/dedup.go
new file mode 100644
index 000000000..fe9ddc96d
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/dedup.go
@@ -0,0 +1,300 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/attrnorm/dedup.go.tmpl
+
+// Package attrnorm normalizes attribute values.
+package attrnorm
+
+import (
+ "reflect"
+ "unsafe"
+
+ "go.opentelemetry.io/otel/attribute"
+)
+
+var (
+ keyValueType = reflect.TypeFor[attribute.KeyValue]()
+ valueType = reflect.TypeFor[attribute.Value]()
+)
+
+// rawValue mirrors attribute.Value. It is used only to read immutable slice
+// storage without calling AsMap or AsSlice on no-op paths.
+type rawValue struct {
+ vtype attribute.Type
+ numeric uint64
+ stringly string
+ slice any
+}
+
+// Value returns value with all map values deduplicated and whether it changed.
+//
+// Duplicate map keys are resolved using last-value-wins semantics.
+func Value(value attribute.Value) (attribute.Value, bool) {
+ switch value.Type() {
+ case attribute.SLICE:
+ return deduplicateSliceValue(value)
+ case attribute.MAP:
+ return deduplicateMapValue(value)
+ default:
+ return value, false
+ }
+}
+
+// KeyValue returns kv with all map values deduplicated and whether it changed.
+func KeyValue(kv attribute.KeyValue) (attribute.KeyValue, bool) {
+ value, changed := Value(kv.Value)
+ if changed {
+ kv.Value = value
+ }
+ return kv, changed
+}
+
+// KeyValues returns kvs with all map values deduplicated and whether they changed.
+//
+// The returned slice is the original kvs slice if no value needs
+// deduplication. Top-level keys in kvs are not deduplicated.
+func KeyValues(kvs []attribute.KeyValue) ([]attribute.KeyValue, bool) {
+ // Preserve the caller's slice on the common no-op path. Once a changed
+ // value is found, copy the prior values exactly once and fill the rest in
+ // place as the scan continues.
+ var normalized []attribute.KeyValue
+ for i, kv := range kvs {
+ kv, changed := KeyValue(kv)
+ if normalized != nil {
+ normalized[i] = kv
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ normalized = make([]attribute.KeyValue, len(kvs))
+ copy(normalized, kvs[:i])
+ normalized[i] = kv
+ }
+ if normalized == nil {
+ return kvs, false
+ }
+ return normalized, true
+}
+
+// Set returns set with all map values deduplicated and whether it changed.
+//
+// The returned Set is the original set if no value needs deduplication.
+// Top-level key uniqueness remains attribute.Set's responsibility; this only
+// normalizes map attribute values.
+func Set(set attribute.Set) (attribute.Set, bool) {
+ if set.Len() == 0 {
+ return set, false
+ }
+
+ // Most attribute sets contain no duplicate map keys. Delay allocation until
+ // the first changed value so the no-op path returns the original Set.
+ var normalized []attribute.KeyValue
+ for i := range set.Len() {
+ kv, _ := set.Get(i)
+ kv, changed := KeyValue(kv)
+ if normalized != nil {
+ normalized = append(normalized, kv)
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ normalized = make([]attribute.KeyValue, 0, set.Len())
+ for j := range i {
+ prior, _ := set.Get(j)
+ normalized = append(normalized, prior)
+ }
+ normalized = append(normalized, kv)
+ }
+ if normalized == nil {
+ return set, false
+ }
+
+ return attribute.NewSet(normalized...), true
+}
+
+func deduplicateSliceValue(value attribute.Value) (attribute.Value, bool) {
+ storage := valueStorage(value)
+ length := valueLen(storage)
+
+ // Slice values can contain map values, so recurse into each element while
+ // keeping the original attribute.Value when no element changes.
+ var normalized []attribute.Value
+ for i := range length {
+ elem := valueAt(storage, i)
+ elem, changed := Value(elem)
+ if normalized != nil {
+ normalized[i] = elem
+ continue
+ }
+ if !changed {
+ continue
+ }
+
+ normalized = make([]attribute.Value, length)
+ for j := range i {
+ normalized[j] = valueAt(storage, j)
+ }
+ normalized[i] = elem
+ }
+ if normalized == nil {
+ return value, false
+ }
+ return attribute.SliceValue(normalized...), true
+}
+
+func deduplicateMapValue(value attribute.Value) (attribute.Value, bool) {
+ storage := valueStorage(value)
+ length := keyValueLen(storage)
+ if length <= 1 {
+ // A single map entry cannot duplicate its own key, but its value might
+ // contain a map or slice that needs recursive normalization.
+ if length == 1 {
+ kv, changed := KeyValue(keyValueAt(storage, 0))
+ if changed {
+ return attribute.MapValue(kv), true
+ }
+ }
+ return value, false
+ }
+
+ var normalized []attribute.KeyValue
+ for i := 0; i < length; {
+ // attribute.MapValue stores key-values sorted by key using a stable
+ // sort. Equal keys therefore form a contiguous run, and the last
+ // element in that run is the last value provided by the caller.
+ first := keyValueAt(storage, i)
+ j := i + 1
+ for j < length && keyValueAt(storage, j).Key == first.Key {
+ j++
+ }
+
+ kv, nestedChanged := KeyValue(keyValueAt(storage, j-1))
+ // j-i > 1 means the current key run contained duplicates.
+ changed := nestedChanged || j-i > 1
+ if normalized != nil {
+ normalized = append(normalized, kv)
+ } else if changed {
+ normalized = make([]attribute.KeyValue, 0, length)
+ for k := range i {
+ normalized = append(normalized, keyValueAt(storage, k))
+ }
+ normalized = append(normalized, kv)
+ }
+ i = j
+ }
+ if normalized == nil {
+ return value, false
+ }
+ return attribute.MapValue(normalized...), true
+}
+
+func valueStorage(value attribute.Value) any {
+ // attribute.Value does not expose allocation-free map/slice iteration.
+ // The raw mirror lets us read the immutable backing array directly and
+ // reserve AsMap/AsSlice-style allocation for paths that actually change.
+ return (*rawValue)(
+ unsafe.Pointer(&value),
+ ).slice //nolint:gosec // Read-only mirror of attribute.Value for allocation-free iteration.
+}
+
+func valueLen(storage any) int {
+ // attribute.Value stores small slices in fixed-size array values. Handle
+ // the common sizes directly and fall back to reflection for larger arrays.
+ switch storage.(type) {
+ case [0]attribute.Value:
+ return 0
+ case [1]attribute.Value:
+ return 1
+ case [2]attribute.Value:
+ return 2
+ case [3]attribute.Value:
+ return 3
+ case [4]attribute.Value:
+ return 4
+ case [5]attribute.Value:
+ return 5
+ default:
+ return arrayLen(storage, valueType)
+ }
+}
+
+func valueAt(storage any, i int) attribute.Value {
+ switch values := storage.(type) {
+ case [1]attribute.Value:
+ return values[i]
+ case [2]attribute.Value:
+ return values[i]
+ case [3]attribute.Value:
+ return values[i]
+ case [4]attribute.Value:
+ return values[i]
+ case [5]attribute.Value:
+ return values[i]
+ default:
+ return arrayAt[attribute.Value](storage, valueType, i)
+ }
+}
+
+func keyValueLen(storage any) int {
+ // attribute.Value stores small maps in fixed-size key-value arrays. Handle
+ // the common sizes directly and fall back to reflection for larger arrays.
+ switch storage.(type) {
+ case [0]attribute.KeyValue:
+ return 0
+ case [1]attribute.KeyValue:
+ return 1
+ case [2]attribute.KeyValue:
+ return 2
+ case [3]attribute.KeyValue:
+ return 3
+ case [4]attribute.KeyValue:
+ return 4
+ case [5]attribute.KeyValue:
+ return 5
+ default:
+ return arrayLen(storage, keyValueType)
+ }
+}
+
+func keyValueAt(storage any, i int) attribute.KeyValue {
+ switch kvs := storage.(type) {
+ case [1]attribute.KeyValue:
+ return kvs[i]
+ case [2]attribute.KeyValue:
+ return kvs[i]
+ case [3]attribute.KeyValue:
+ return kvs[i]
+ case [4]attribute.KeyValue:
+ return kvs[i]
+ case [5]attribute.KeyValue:
+ return kvs[i]
+ default:
+ return arrayAt[attribute.KeyValue](storage, keyValueType, i)
+ }
+}
+
+func arrayLen(storage any, elem reflect.Type) int {
+ // Be defensive around invalid or unexpected Value storage. Returning zero
+ // makes malformed storage a no-op instead of panicking in telemetry paths.
+ array := reflect.ValueOf(storage)
+ if array.Kind() != reflect.Array || array.Type().Elem() != elem {
+ return 0
+ }
+ return array.Len()
+}
+
+func arrayAt[T any](storage any, elem reflect.Type, i int) T {
+ // Match arrayLen's fail-closed behavior for unexpected storage.
+ array := reflect.ValueOf(storage)
+ if array.Kind() != reflect.Array || array.Type().Elem() != elem || i < 0 || i >= array.Len() {
+ var zero T
+ return zero
+ }
+ return array.Index(i).Interface().(T)
+}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/truncate.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/truncate.go
new file mode 100644
index 000000000..9955e9072
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/attrnorm/truncate.go
@@ -0,0 +1,232 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/attrnorm/truncate.go.tmpl
+
+package attrnorm
+
+import (
+ "slices"
+ "strings"
+ "unicode/utf8"
+
+ "go.opentelemetry.io/otel/attribute"
+)
+
+// Truncate returns a truncated version of attr. Only string, string slice,
+// byte slice, slice, and map attribute values are truncated. String values are
+// truncated to at most a length of limit. Each string slice value is truncated
+// in this fashion (the slice length itself is unaffected), and byte slice
+// values are truncated to at most limit bytes. For slice and map attribute
+// values, the limit is applied recursively to contained values.
+//
+// No truncation is performed for a negative limit.
+func Truncate(limit int, attr attribute.KeyValue) attribute.KeyValue {
+ if limit < 0 {
+ return attr
+ }
+ switch attr.Value.Type() {
+ case attribute.STRING:
+ v := attr.Value.AsString()
+ return attr.Key.String(truncate(limit, v))
+ case attribute.STRINGSLICE:
+ v := attr.Value.AsStringSlice()
+ for i := range v {
+ v[i] = truncate(limit, v[i])
+ }
+ return attr.Key.StringSlice(v)
+ case attribute.BYTESLICE:
+ v := attr.Value.AsString()
+ if len(v) > limit {
+ return attr.Key.ByteSlice([]byte(v[:limit]))
+ }
+ return attr
+ case attribute.SLICE:
+ v := attr.Value.AsSlice()
+ if !slices.ContainsFunc(v, func(e attribute.Value) bool { return needsTruncation(limit, e) }) {
+ return attr
+ }
+ newV := make([]attribute.Value, len(v))
+ for i, elem := range v {
+ newV[i] = TruncateValue(limit, elem)
+ }
+ return attr.Key.Slice(newV...)
+ case attribute.MAP:
+ v := attr.Value.AsMap()
+ if !slices.ContainsFunc(v, func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }) {
+ return attr
+ }
+ newV := make([]attribute.KeyValue, len(v))
+ for i, elem := range v {
+ elem.Value = TruncateValue(limit, elem.Value)
+ newV[i] = elem
+ }
+ return attr.Key.Map(newV...)
+ }
+ return attr
+}
+
+// TruncateValue returns a truncated version of v. Only string, string
+// slice, byte slice, and (recursively) slice and map values are modified.
+//
+// No truncation is performed for a negative limit.
+func TruncateValue(limit int, v attribute.Value) attribute.Value {
+ if limit < 0 {
+ return v
+ }
+
+ switch v.Type() {
+ case attribute.STRING:
+ return attribute.StringValue(truncate(limit, v.AsString()))
+ case attribute.STRINGSLICE:
+ ss := v.AsStringSlice()
+ for i := range ss {
+ ss[i] = truncate(limit, ss[i])
+ }
+ return attribute.StringSliceValue(ss)
+ case attribute.BYTESLICE:
+ // len(v.AsString()) is identical to len(v.AsByteSlice()) but
+ // avoids allocating the full slice before truncation.
+ s := v.AsString()
+ if limit >= 0 && len(s) > limit {
+ return attribute.ByteSliceValue([]byte(s[:limit]))
+ }
+ case attribute.SLICE:
+ sl := v.AsSlice()
+ if !slices.ContainsFunc(sl, func(e attribute.Value) bool { return needsTruncation(limit, e) }) {
+ return v
+ }
+ newSl := make([]attribute.Value, len(sl))
+ for i, elem := range sl {
+ newSl[i] = TruncateValue(limit, elem)
+ }
+ return attribute.SliceValue(newSl...)
+ case attribute.MAP:
+ m := v.AsMap()
+ if !slices.ContainsFunc(m, func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) }) {
+ return v
+ }
+ newM := make([]attribute.KeyValue, len(m))
+ for i, elem := range m {
+ elem.Value = TruncateValue(limit, elem.Value)
+ newM[i] = elem
+ }
+ return attribute.MapValue(newM...)
+ }
+ return v
+}
+
+// stringNeedsTruncation reports whether s would be modified by truncate for the
+// given limit.
+func stringNeedsTruncation(limit int, s string) bool {
+ if limit < 0 || len(s) <= limit {
+ return false
+ }
+ return utf8.RuneCountInString(s) > limit || !utf8.ValidString(s)
+}
+
+// needsTruncation reports whether v would be modified by TruncateValue for the
+// given limit.
+func needsTruncation(limit int, v attribute.Value) bool {
+ switch v.Type() {
+ case attribute.STRING:
+ return stringNeedsTruncation(limit, v.AsString())
+ case attribute.BYTESLICE:
+ // len(v.AsString()) is identical to len(v.AsByteSlice()) but
+ // avoids memory allocation.
+ if limit >= 0 && len(v.AsString()) > limit {
+ return true
+ }
+ case attribute.STRINGSLICE:
+ for _, s := range v.AsStringSlice() {
+ if stringNeedsTruncation(limit, s) {
+ return true
+ }
+ }
+ case attribute.SLICE:
+ return slices.ContainsFunc(v.AsSlice(), func(e attribute.Value) bool { return needsTruncation(limit, e) })
+ case attribute.MAP:
+ return slices.ContainsFunc(
+ v.AsMap(),
+ func(kv attribute.KeyValue) bool { return needsTruncation(limit, kv.Value) },
+ )
+ }
+ return false
+}
+
+// truncate returns a truncated version of s such that it contains less than
+// the limit number of characters. Truncation is applied by returning the limit
+// number of valid characters contained in s.
+//
+// If limit is negative, it returns the original string.
+//
+// UTF-8 is supported. When truncating, all invalid characters are dropped
+// before applying truncation.
+//
+// If s already contains less than the limit number of bytes, it is returned
+// unchanged. No invalid characters are removed.
+func truncate(limit int, s string) string {
+ // This prioritize performance in the following order based on the most
+ // common expected use-cases.
+ //
+ // - Short values less than the default limit (128).
+ // - Strings with valid encodings that exceed the limit.
+ // - No limit.
+ // - Strings with invalid encodings that exceed the limit.
+ if limit < 0 || len(s) <= limit {
+ return s
+ }
+
+ // Optimistically, assume all valid UTF-8.
+ var b strings.Builder
+ count := 0
+ for i, c := range s {
+ if c != utf8.RuneError {
+ count++
+ if count > limit {
+ return s[:i]
+ }
+ continue
+ }
+
+ _, size := utf8.DecodeRuneInString(s[i:])
+ if size == 1 {
+ // Invalid encoding.
+ b.Grow(len(s) - 1)
+ _, _ = b.WriteString(s[:i])
+ s = s[i:]
+ break
+ }
+ }
+
+ // Fast-path, no invalid input.
+ if b.Cap() == 0 {
+ return s
+ }
+
+ // Truncate while validating UTF-8.
+ for i := 0; i < len(s) && count < limit; {
+ c := s[i]
+ if c < utf8.RuneSelf {
+ // Optimization for single byte runes (common case).
+ _ = b.WriteByte(c)
+ i++
+ count++
+ continue
+ }
+
+ _, size := utf8.DecodeRuneInString(s[i:])
+ if size == 1 {
+ // We checked for all 1-byte runes above, this is a RuneError.
+ i++
+ continue
+ }
+
+ _, _ = b.WriteString(s[i : i+size])
+ i += size
+ count++
+ }
+
+ return b.String()
+}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/counter/counter.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/counter/counter.go
new file mode 100644
index 000000000..57c6acb78
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/counter/counter.go
@@ -0,0 +1,31 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/counter/counter.go.tmpl
+
+// Package counter provides a simple counter for generating unique IDs.
+//
+// This package is used to generate unique IDs while allowing testing packages
+// to reset the counter.
+package counter
+
+import "sync/atomic"
+
+// exporterN is a global 0-based count of the number of exporters created.
+var exporterN atomic.Int64
+
+// NextExporterID returns the next unique ID for an exporter.
+func NextExporterID() int64 {
+ const inc = 1
+ return exporterN.Add(inc) - inc
+}
+
+// SetExporterID sets the exporter ID counter to v and returns the previous
+// value.
+//
+// This function is useful for testing purposes, allowing you to reset the
+// counter. It should not be used in production code.
+func SetExporterID(v int64) int64 {
+ return exporterN.Swap(v)
+}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/batch_log_processor.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/batch_log_processor.go
new file mode 100644
index 000000000..e6c6d6074
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/batch_log_processor.go
@@ -0,0 +1,127 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package observ
+
+import (
+ "context"
+ "errors"
+ "fmt"
+
+ "go.opentelemetry.io/otel"
+ "go.opentelemetry.io/otel/attribute"
+ "go.opentelemetry.io/otel/metric"
+ "go.opentelemetry.io/otel/sdk"
+ "go.opentelemetry.io/otel/sdk/log/internal/x"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
+)
+
+const (
+ // SchemaURL is the schema URL of the instrumentation.
+ SchemaURL = semconv.SchemaURL
+)
+
+// ErrQueueFull is the attribute value for the "queue_full" error type.
+var ErrQueueFull = otelconv.SDKProcessorLogProcessed{}.AttrErrorType("queue_full")
+
+// BLPComponentName returns the component name attribute for a
+// BatchLogProcessor with the given ID.
+func BLPComponentName(id int64) attribute.KeyValue {
+ t := otelconv.ComponentTypeBatchingLogProcessor
+ name := fmt.Sprintf("%s/%d", t, id)
+ return semconv.OTelComponentName(name)
+}
+
+// BLP is the instrumentation for an OTel SDK BatchLogProcessor.
+type BLP struct {
+ reg metric.Registration
+
+ processed metric.Int64Counter
+ processedOpts []metric.AddOption
+ processedQueueFullOpts []metric.AddOption
+}
+
+// NewBLP creates a new BatchLogProcessor instrumentation.
+// Returns nil if observability is not enabled.
+func NewBLP(id int64, qLen func() int64, qMax int64) (*BLP, error) {
+ if !x.Observability.Enabled() {
+ return nil, nil
+ }
+ if qLen == nil {
+ return nil, errors.New("BLP qLen must not be nil")
+ }
+
+ meter := otel.GetMeterProvider().Meter(
+ ScopeName,
+ metric.WithInstrumentationVersion(sdk.Version()),
+ metric.WithSchemaURL(SchemaURL),
+ )
+
+ qCap, err := otelconv.NewSDKProcessorLogQueueCapacity(meter)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create BLP queue capacity metric: %w", err)
+ }
+ qCapInst := qCap.Inst()
+
+ qSize, err := otelconv.NewSDKProcessorLogQueueSize(meter)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create BLP queue size metric: %w", err)
+ }
+ qSizeInst := qSize.Inst()
+
+ cmpntT := semconv.OTelComponentTypeBatchingLogProcessor
+ cmpnt := BLPComponentName(id)
+ set := attribute.NewSet(cmpnt, cmpntT)
+
+ // Register callback for async metrics
+ obsOpts := []metric.ObserveOption{metric.WithAttributeSet(set)}
+ reg, err := meter.RegisterCallback(
+ func(_ context.Context, o metric.Observer) error {
+ o.ObserveInt64(qSizeInst, qLen(), obsOpts...)
+ o.ObserveInt64(qCapInst, qMax, obsOpts...)
+ return nil
+ },
+ qSizeInst,
+ qCapInst,
+ )
+ if err != nil {
+ return nil, fmt.Errorf("failed to register BLP queue size/capacity callback: %w", err)
+ }
+
+ processed, err := otelconv.NewSDKProcessorLogProcessed(meter)
+ if err != nil {
+ _ = reg.Unregister()
+ return nil, fmt.Errorf("failed to create BLP processed logs metric: %w", err)
+ }
+
+ processedOpts := []metric.AddOption{metric.WithAttributeSet(set)}
+ setWithError := attribute.NewSet(cmpnt, cmpntT, ErrQueueFull)
+ processedQueueFullOpts := []metric.AddOption{metric.WithAttributeSet(setWithError)}
+
+ return &BLP{
+ reg: reg,
+ processed: processed.Inst(),
+ processedOpts: processedOpts,
+ processedQueueFullOpts: processedQueueFullOpts,
+ }, nil
+}
+
+func (b *BLP) Shutdown() error {
+ if b == nil || b.reg == nil {
+ return nil
+ }
+ return b.reg.Unregister()
+}
+
+func (b *BLP) Processed(ctx context.Context, n int64) {
+ if b.processed.Enabled(ctx) {
+ b.processed.Add(ctx, n, b.processedOpts...)
+ }
+}
+
+func (b *BLP) ProcessedQueueFull(ctx context.Context, n int64) {
+ if b.processed.Enabled(ctx) {
+ b.processed.Add(ctx, n, b.processedQueueFullOpts...)
+ }
+}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go
index 6879567cb..1c52a93e3 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/doc.go
@@ -3,4 +3,4 @@
// Package observ provides observability instrumentation for the OTel log SDK
// package.
-package observ // import "go.opentelemetry.io/otel/sdk/log/internal/observ"
+package observ
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go
index 916bdc67e..9f19320ad 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/observ/simple_log_processor.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/sdk/log/internal/observ"
+package observ
import (
"context"
@@ -14,8 +14,8 @@ import (
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/sdk"
"go.opentelemetry.io/otel/sdk/log/internal/x"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
const (
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md
index 33176f78e..5c06e2723 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/README.md
@@ -19,6 +19,9 @@ To opt-in, set the environment variable `OTEL_GO_X_OBSERVABILITY` to `true`.
When enabled, the SDK will create the following metrics using the global `MeterProvider`:
- `otel.sdk.log.created`
+- `otel.sdk.processor.log.queue.capacity`
+- `otel.sdk.processor.log.queue.size`
+- `otel.sdk.processor.log.processed`
Please see the [Semantic conventions for OpenTelemetry SDK metrics] documentation for more details on these metrics.
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go
index e0ac88a42..76e1bf7e2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/features.go
@@ -2,7 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
// Package x documents experimental features for [go.opentelemetry.io/otel/sdk/log].
-package x // import "go.opentelemetry.io/otel/sdk/log/internal/x"
+package x
import "strings"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go
index e597efb10..90a1660bc 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/internal/x/x.go
@@ -1,11 +1,11 @@
-// Code generated by gotmpl. DO NOT MODIFY.
-// source: internal/shared/x/x.go.tmpl
-
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
+// DO NOT MODIFY. Generated by gotmpl.
+// source: internal/shared/x/x.go.tmpl
+
// Package x documents experimental features for [go.opentelemetry.io/otel/sdk/log].
-package x // import "go.opentelemetry.io/otel/sdk/log/internal/x"
+package x
import (
"os"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/logger.go b/vendor/go.opentelemetry.io/otel/sdk/log/logger.go
index ce63f4e30..7f8adcf66 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/logger.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/logger.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
@@ -11,19 +11,19 @@ import (
"time"
"go.opentelemetry.io/otel"
+ "go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/log"
"go.opentelemetry.io/otel/log/embedded"
"go.opentelemetry.io/otel/sdk/instrumentation"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
"go.opentelemetry.io/otel/trace"
)
var now = time.Now
const (
- exceptionTypeKey = string(semconv.ExceptionTypeKey)
- exceptionMessageKey = string(semconv.ExceptionMessageKey)
- exceptionStacktraceKey = string(semconv.ExceptionStacktraceKey)
+ exceptionTypeKey = semconv.ExceptionTypeKey
+ exceptionMessageKey = semconv.ExceptionMessageKey
)
// Compile-time check logger implements log.Logger.
@@ -55,17 +55,50 @@ func newLogger(p *LoggerProvider, scope instrumentation.Scope) *logger {
}
func (l *logger) Emit(ctx context.Context, r log.Record) {
+ processors := l.provider.processors
+ if len(processors) == 0 {
+ if l.provider.stopped.Load() {
+ return
+ }
+ // Emit remains observable without processors, but no lifecycle
+ // admission or SDK record construction is needed.
+ l.recordCreated(ctx)
+ return
+ }
+
+ for _, err := range l.emit(ctx, r, processors) {
+ otel.Handle(err)
+ }
+}
+
+func (l *logger) emit(ctx context.Context, r log.Record, processors []Processor) []error {
+ if !l.provider.beginProcessorOperation() {
+ return nil
+ }
+ defer l.provider.endProcessorOperation()
+
+ l.recordCreated(ctx)
newRecord := l.newRecord(ctx, r)
- for _, p := range l.provider.processors {
- if err := p.OnEmit(ctx, &newRecord); err != nil {
- otel.Handle(err)
+ var errs []error
+ for _, processor := range processors {
+ if err := processor.OnEmit(ctx, &newRecord); err != nil {
+ errs = append(errs, err)
}
}
+ return errs
+}
+
+func (l *logger) recordCreated(ctx context.Context) {
+ if l.recCntIncr != nil {
+ l.recCntIncr(ctx)
+ }
}
// Enabled returns true if at least one Processor held by the LoggerProvider
// that created the logger will process for the provided context and param.
//
+// Enabled returns false after the LoggerProvider that created l starts shutdown.
+//
// If it is not possible to definitively determine the record will be
// processed, true will be returned by default. A value of false will only be
// returned if it can be positively verified that no Processor will process.
@@ -76,7 +109,13 @@ func (l *logger) Enabled(ctx context.Context, param log.EnabledParameters) bool
EventName: param.EventName,
}
- for _, processor := range l.provider.processors {
+ processors := l.provider.processors
+ if len(processors) == 0 || !l.provider.beginProcessorOperation() {
+ return false
+ }
+ defer l.provider.endProcessorOperation()
+
+ for _, processor := range processors {
if processor.Enabled(ctx, p) {
// At least one Processor will process the Record.
return true
@@ -106,10 +145,6 @@ func (l *logger) newRecord(ctx context.Context, r log.Record) Record {
attributeCountLimit: l.provider.attributeCountLimit,
allowDupKeys: l.provider.allowDupKeys,
}
- if l.recCntIncr != nil {
- l.recCntIncr(ctx)
- }
-
// This ensures we deduplicate key-value collections in the log body
newRecord.SetBody(r.Body())
@@ -118,45 +153,63 @@ func (l *logger) newRecord(ctx context.Context, r log.Record) Record {
newRecord.observedTimestamp = now()
}
- hasExceptionAttr := false
- r.WalkAttributes(func(kv log.KeyValue) bool {
+ // User-provided exception attributes MUST take precedence. Track message
+ // and type independently so a supplied value suppresses only its own
+ // derivation.
+ var hasExceptionMessage, hasExceptionType bool
+ r.WalkAttributes(func(kv attribute.KeyValue) bool {
switch kv.Key {
- case exceptionTypeKey, exceptionMessageKey, exceptionStacktraceKey:
- hasExceptionAttr = true
+ case exceptionMessageKey:
+ hasExceptionMessage = true
+ case exceptionTypeKey:
+ hasExceptionType = true
}
newRecord.AddAttributes(kv)
return true
})
- if err := r.Err(); err != nil && !hasExceptionAttr {
- addExceptionAttrs(&newRecord, err)
- }
-
- return newRecord
-}
-
-func addExceptionAttrs(r *Record, err error) {
- var attrs [2]log.KeyValue
- n := 0
- if msg := err.Error(); msg != "" {
- if r.attributeCountLimit > 0 && r.attributeCountLimit-r.AttributesLen() < n+1 {
- goto flush
+ // Avoid inspecting the error for attributes when the caller has
+ // already supplied the attributes.
+ if err := r.Err(); err != nil && (!hasExceptionMessage || !hasExceptionType) {
+ // Derive missing exception attributes by default, as required by the
+ // Logs SDK specification. Attribute limits may constrain generation,
+ // so stop once there is no capacity for another attribute.
+ var attrs [2]attribute.KeyValue
+ n := 0
+
+ // Derived attributes are buffered until flush, so the current attribute
+ // count stays unchanged while missing values are prepared.
+ hasLimit := newRecord.hasAttributeCountLimit()
+ var remaining int
+ if hasLimit {
+ remaining = newRecord.attributeCountLimit - newRecord.AttributesLen()
}
- attrs[n] = log.String(exceptionMessageKey, msg)
- n++
- }
- if errType := errorType(err); errType != "" {
- if r.attributeCountLimit > 0 && r.attributeCountLimit-r.AttributesLen() < n+1 {
- goto flush
+ if !hasExceptionMessage {
+ if msg := err.Error(); msg != "" {
+ if hasLimit && remaining <= n {
+ goto flush
+ }
+ attrs[n] = exceptionMessageKey.String(msg)
+ n++
+ }
+ }
+ if !hasExceptionType {
+ if errType := errorType(err); errType != "" {
+ if hasLimit && remaining <= n {
+ goto flush
+ }
+ attrs[n] = exceptionTypeKey.String(errType)
+ n++
+ }
}
- attrs[n] = log.String(exceptionTypeKey, errType)
- n++
- }
-flush:
- if n > 0 {
- r.addAttrs(attrs[:n])
+ flush:
+ if n > 0 {
+ newRecord.addAttrs(attrs[:n])
+ }
}
+
+ return newRecord
}
func errorType(err error) string {
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/processor.go b/vendor/go.opentelemetry.io/otel/sdk/log/processor.go
index ba6319c09..31cd72c20 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/processor.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
@@ -12,13 +12,23 @@ import (
// Processor handles the processing of log records.
//
-// Any of the Processor's methods may be called concurrently with itself
-// or with other methods. It is the responsibility of the Processor to manage
-// this concurrency.
+// Enabled, OnEmit, and ForceFlush may be called concurrently with themselves
+// or each other. It is the responsibility of the Processor to manage this
+// concurrency.
+//
+// A Processor must be registered only once and with a single
+// [LoggerProvider]. Registering the same Processor with multiple providers or
+// multiple times with the same provider is not supported.
+//
+// A [LoggerProvider] stops admitting new operations that invoke Enabled,
+// OnEmit, or ForceFlush when shutdown starts. Callers that use a Processor
+// directly are responsible for coordinating those calls with Shutdown.
type Processor interface {
// Enabled reports whether the Processor will process for the given context
// and param.
//
+ // Enabled is called synchronously and should not block.
+ //
// The param contains a subset of the information that will be available
// in the Record passed to OnEmit, as defined by EnabledParameters.
// A field being unset in param does not imply the corresponding field
@@ -42,12 +52,12 @@ type Processor interface {
// The SDK's Logger.Enabled returns false if all the registered processors
// return false. Otherwise, it returns true.
//
- // Implementations of this method need to be safe for a user to call
- // concurrently.
Enabled(ctx context.Context, param EnabledParameters) bool
// OnEmit is called when a Record is emitted.
//
+ // OnEmit is called synchronously and should not block.
+ //
// OnEmit will be called independent of Enabled. Implementations need to
// validate the arguments themselves before processing.
//
@@ -73,6 +83,13 @@ type Processor interface {
// resources held by the Processor (and any underlying Exporter) should be
// done in this call.
//
+ // A LoggerProvider calls Shutdown at most once. Before calling it, the
+ // LoggerProvider waits for all Enabled, OnEmit, and ForceFlush calls it
+ // admitted to complete. If the LoggerProvider's Shutdown context is canceled
+ // while waiting, Shutdown is not called.
+ //
+ // Shutdown must include the effects of ForceFlush.
+ //
// The deadline or cancellation of the passed context must be honored. An
// appropriate error should be returned in these situations.
//
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/provider.go b/vendor/go.opentelemetry.io/otel/sdk/log/provider.go
index 4ac799bfd..cf5472c0d 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/provider.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/provider.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
@@ -15,6 +15,7 @@ import (
"go.opentelemetry.io/otel/log/embedded"
"go.opentelemetry.io/otel/log/noop"
"go.opentelemetry.io/otel/sdk/instrumentation"
+ "go.opentelemetry.io/otel/sdk/log/internal/attrnorm"
"go.opentelemetry.io/otel/sdk/resource"
)
@@ -65,7 +66,11 @@ func newProviderConfig(opts []LoggerProviderOption) providerConfig {
}
// LoggerProvider handles the creation and coordination of Loggers. All Loggers
-// created by a LoggerProvider will be associated with the same Resource.
+// it creates are associated with the same Resource.
+//
+// After [LoggerProvider.Shutdown] starts, calls to [log.Logger.Enabled] on
+// Loggers created by the LoggerProvider return false, and calls to
+// [log.Logger.Emit] perform no operation.
type LoggerProvider struct {
embedded.LoggerProvider
@@ -78,7 +83,10 @@ type LoggerProvider struct {
loggersMu sync.Mutex
loggers map[instrumentation.Scope]*logger
- stopped atomic.Bool
+ stopped atomic.Bool
+ processorOperationsMu sync.Mutex
+ processorOperationsActive int
+ processorOperationsDone chan struct{}
noCmp [0]func() //nolint: unused // This is indeed used.
}
@@ -105,7 +113,7 @@ func NewLoggerProvider(opts ...LoggerProviderOption) *LoggerProvider {
// Logger returns a new [log.Logger] with the provided name and configuration.
//
-// If p is shut down, a [noop.Logger] instance is returned.
+// Calls made after [LoggerProvider.Shutdown] starts return a [noop.Logger].
//
// This method can be called concurrently.
func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logger {
@@ -118,11 +126,15 @@ func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logge
}
cfg := log.NewLoggerConfig(opts...)
+ attrs := cfg.InstrumentationAttributes()
+ if !p.allowDupKeys {
+ attrs, _ = attrnorm.Set(attrs)
+ }
scope := instrumentation.Scope{
Name: name,
Version: cfg.InstrumentationVersion(),
SchemaURL: cfg.SchemaURL(),
- Attributes: cfg.InstrumentationAttributes(),
+ Attributes: attrs,
}
p.loggersMu.Lock()
@@ -143,14 +155,40 @@ func (p *LoggerProvider) Logger(name string, opts ...log.LoggerOption) log.Logge
return l
}
-// Shutdown shuts down the provider and all processors.
+// Shutdown shuts down the provider and all processors in the order they were
+// registered.
+//
+// The first call stops admitting new operations that invoke processor Enabled,
+// OnEmit, or ForceFlush methods. It waits for operations already admitted to
+// complete before synchronously invoking each processor's Shutdown method. If
+// ctx is canceled before the admitted operations complete, Shutdown returns
+// ctx.Err() without invoking processor Shutdown.
+//
+// Concurrent or subsequent Shutdown calls return nil without invoking
+// processor Shutdown.
+//
+// Shutdown must not be called directly or indirectly from a Processor method.
//
// This method can be called concurrently.
func (p *LoggerProvider) Shutdown(ctx context.Context) error {
- stopped := p.stopped.Swap(true)
- if stopped {
+ p.processorOperationsMu.Lock()
+ if p.stopped.Load() {
+ p.processorOperationsMu.Unlock()
return nil
}
+ p.processorOperationsDone = make(chan struct{})
+ p.stopped.Store(true)
+ if p.processorOperationsActive == 0 {
+ close(p.processorOperationsDone)
+ }
+ p.processorOperationsMu.Unlock()
+
+ // All count updates happen while processorOperationsMu is held. Therefore,
+ // either Shutdown observes zero operations and closes the channel above, or
+ // the final operation observes stopped and closes it synchronously.
+ if err := p.waitForProcessorOperations(ctx); err != nil {
+ return err
+ }
var err error
for _, p := range p.processors {
@@ -161,11 +199,14 @@ func (p *LoggerProvider) Shutdown(ctx context.Context) error {
// ForceFlush flushes all processors.
//
+// Once Shutdown starts, ForceFlush performs no operation and returns nil.
+//
// This method can be called concurrently.
func (p *LoggerProvider) ForceFlush(ctx context.Context) error {
- if p.stopped.Load() {
+ if len(p.processors) == 0 || !p.beginProcessorOperation() {
return nil
}
+ defer p.endProcessorOperation()
var err error
for _, p := range p.processors {
@@ -174,6 +215,47 @@ func (p *LoggerProvider) ForceFlush(ctx context.Context) error {
return err
}
+func (p *LoggerProvider) beginProcessorOperation() bool {
+ p.processorOperationsMu.Lock()
+ defer p.processorOperationsMu.Unlock()
+ if p.stopped.Load() {
+ return false
+ }
+ p.processorOperationsActive++
+ return true
+}
+
+func (p *LoggerProvider) endProcessorOperation() {
+ p.processorOperationsMu.Lock()
+ defer p.processorOperationsMu.Unlock()
+ p.processorOperationsActive--
+ if p.processorOperationsActive == 0 && p.stopped.Load() {
+ close(p.processorOperationsDone)
+ }
+}
+
+func (p *LoggerProvider) waitForProcessorOperations(ctx context.Context) error {
+ if err := ctx.Err(); err != nil {
+ return err
+ }
+
+ return waitForProcessorOperationsCompletion(ctx, p.processorOperationsDone)
+}
+
+func waitForProcessorOperationsCompletion(ctx context.Context, done <-chan struct{}) error {
+ select {
+ case <-done:
+ case <-ctx.Done():
+ // Prefer a completed drain when it races with cancellation.
+ select {
+ case <-done:
+ default:
+ return ctx.Err()
+ }
+ }
+ return nil
+}
+
// LoggerProviderOption applies a configuration option value to a LoggerProvider.
type LoggerProviderOption interface {
apply(providerConfig) providerConfig
@@ -257,17 +339,23 @@ func WithAttributeValueLengthLimit(limit int) LoggerProviderOption {
})
}
-// WithAllowKeyDuplication sets whether deduplication is skipped for log attributes or other key-value collections.
+// WithAllowKeyDuplication sets whether deduplication is skipped for log record
+// and instrumentation scope key-value collections.
//
-// By default, the key-value collections within a log record are deduplicated to comply with the OpenTelemetry Specification.
-// Deduplication means that if multiple key–value pairs with the same key are present, only a single pair
-// is retained and others are discarded.
+// By default, the key-value collections within a log record and
+// instrumentation scope are deduplicated to comply with the OpenTelemetry
+// Specification.
+// Deduplication means that if multiple key-value pairs with the same key are
+// present, only a single pair is retained and others are discarded. Resource
+// attributes are always deduplicated by go.opentelemetry.io/otel/sdk/resource.
//
-// Disabling deduplication with this option can improve performance e.g. of adding attributes to the log record.
+// Disabling deduplication with this option can improve performance e.g. of
+// adding attributes to the log record.
//
-// Note that if you disable deduplication, you are responsible for ensuring that duplicate
-// key-value pairs within in a single collection are not emitted,
-// or that the telemetry receiver can handle such duplicates.
+// Receivers may handle duplicate keys unpredictably. If you disable
+// deduplication, you are responsible for ensuring that duplicate keys within a
+// single collection are not emitted, or that the telemetry receiver can handle
+// such duplicates.
func WithAllowKeyDuplication() LoggerProviderOption {
return loggerProviderOptionFunc(func(cfg providerConfig) providerConfig {
cfg.allowDupKeys = newSetting(true)
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/record.go b/vendor/go.opentelemetry.io/otel/sdk/log/record.go
index 80b8bfa1e..6f64e04e3 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/record.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/record.go
@@ -1,18 +1,18 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"slices"
- "strings"
"sync"
"time"
- "unicode/utf8"
+ "go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/internal/global"
"go.opentelemetry.io/otel/log"
"go.opentelemetry.io/otel/sdk/instrumentation"
+ "go.opentelemetry.io/otel/sdk/log/internal/attrnorm"
"go.opentelemetry.io/otel/sdk/resource"
"go.opentelemetry.io/otel/trace"
)
@@ -37,14 +37,14 @@ var logKeyValuePairDropped = sync.OnceFunc(func() {
// uniquePool is a pool of unique attributes used for attributes de-duplication.
var uniquePool = sync.Pool{
- New: func() any { return new([]log.KeyValue) },
+ New: func() any { return new([]attribute.KeyValue) },
}
-func getUnique() *[]log.KeyValue {
- return uniquePool.Get().(*[]log.KeyValue)
+func getUnique() *[]attribute.KeyValue {
+ return uniquePool.Get().(*[]attribute.KeyValue)
}
-func putUnique(v *[]log.KeyValue) {
+func putUnique(v *[]attribute.KeyValue) {
if cap(*v) <= maxUniqueSize {
clear(*v)
*v = (*v)[:0]
@@ -54,32 +54,18 @@ func putUnique(v *[]log.KeyValue) {
// indexPool is a pool of index maps used for attributes de-duplication.
var indexPool = sync.Pool{
- New: func() any { return make(map[string]int) },
+ New: func() any { return make(map[attribute.Key]int) },
}
-func getIndex() map[string]int {
- return indexPool.Get().(map[string]int)
+func getIndex() map[attribute.Key]int {
+ return indexPool.Get().(map[attribute.Key]int)
}
-func putIndex(index map[string]int) {
+func putIndex(index map[attribute.Key]int) {
clear(index)
indexPool.Put(index)
}
-// seenPool is a pool of seen keys used for maps de-duplication.
-var seenPool = sync.Pool{
- New: func() any { return make(map[string]struct{}) },
-}
-
-func getSeen() map[string]struct{} {
- return seenPool.Get().(map[string]struct{})
-}
-
-func putSeen(seen map[string]struct{}) {
- clear(seen)
- seenPool.Put(seen)
-}
-
// Record is a log record emitted by the Logger.
// A log record with non-empty event name is interpreted as an event record.
//
@@ -95,7 +81,7 @@ type Record struct {
observedTimestamp time.Time
severity log.Severity
severityText string
- body log.Value
+ body attribute.Value
// The fields below are for optimizing the implementation of Attributes and
// AddAttributes. This design is borrowed from the slog Record type:
@@ -104,7 +90,7 @@ type Record struct {
// Allocation optimization: an inline array sized to hold
// the majority of log calls (based on examination of open-source
// code). It holds the start of the list of attributes.
- front [attributesInlineCount]log.KeyValue
+ front [attributesInlineCount]attribute.KeyValue
// The number of attributes in front.
nFront int
@@ -113,7 +99,7 @@ type Record struct {
// Invariants:
// - len(back) > 0 if nFront == len(front)
// - Unused array elements are zero-ed. Used to detect mistakes.
- back []log.KeyValue
+ back []attribute.KeyValue
// dropped is the count of attributes that have been dropped when limits
// were reached.
@@ -200,22 +186,22 @@ func (r *Record) SetSeverityText(text string) {
}
// Body returns the body of the log record.
-func (r *Record) Body() log.Value {
+func (r *Record) Body() attribute.Value {
return r.body
}
// SetBody sets the body of the log record.
-func (r *Record) SetBody(v log.Value) {
+func (r *Record) SetBody(v attribute.Value) {
if !r.allowDupKeys {
- r.body = r.dedupeBodyCollections(v)
+ r.body, _ = attrnorm.Value(v)
} else {
r.body = v
}
}
// WalkAttributes walks all attributes the log record holds by calling f for
-// each on each [log.KeyValue] in the [Record]. Iteration stops if f returns false.
-func (r *Record) WalkAttributes(f func(log.KeyValue) bool) {
+// each on each [attribute.KeyValue] in the [Record]. Iteration stops if f returns false.
+func (r *Record) WalkAttributes(f func(attribute.KeyValue) bool) {
for i := 0; i < r.nFront; i++ {
if !f(r.front[i]) {
return
@@ -230,7 +216,7 @@ func (r *Record) WalkAttributes(f func(log.KeyValue) bool) {
// AddAttributes adds attributes to the log record.
// Attributes in attrs will overwrite any attribute already added to r with the same key.
-func (r *Record) AddAttributes(attrs ...log.KeyValue) {
+func (r *Record) AddAttributes(attrs ...attribute.KeyValue) {
n := r.AttributesLen()
if n == 0 {
// Avoid the more complex duplicate map lookups below.
@@ -242,7 +228,7 @@ func (r *Record) AddAttributes(attrs ...log.KeyValue) {
}
}
- attrs, drop := head(attrs, r.attributeCountLimit)
+ attrs, drop := r.head(attrs)
r.addDropped(drop)
r.addAttrs(attrs)
@@ -295,12 +281,12 @@ func (r *Record) AddAttributes(attrs ...log.KeyValue) {
}
if dropped > 0 {
- attrs = make([]log.KeyValue, len(*unique))
+ attrs = make([]attribute.KeyValue, len(*unique))
copy(attrs, *unique)
}
}
- if r.attributeCountLimit > 0 && n+len(attrs) > r.attributeCountLimit {
+ if r.hasAttributeCountLimit() && n+len(attrs) > r.attributeCountLimit {
// Truncate the now unique attributes to comply with limit.
//
// Do not use head(attrs, r.attributeCountLimit - n) here. If
@@ -320,7 +306,7 @@ func (r *Record) AddAttributes(attrs ...log.KeyValue) {
//
// The returned index is taken from the indexPool. It is the callers
// responsibility to return the index to that pool (putIndex) when done.
-func (r *Record) attrIndex() map[string]int {
+func (r *Record) attrIndex() map[attribute.Key]int {
index := getIndex()
for i := 0; i < r.nFront; i++ {
key := r.front[i].Key
@@ -336,7 +322,7 @@ func (r *Record) attrIndex() map[string]int {
// addAttrs adds attrs to the Record r. This does not validate any limits or
// duplication of attributes, these tasks are left to the caller to handle
// prior to calling.
-func (r *Record) addAttrs(attrs []log.KeyValue) {
+func (r *Record) addAttrs(attrs []attribute.KeyValue) {
var i int
for i = 0; i < len(attrs) && r.nFront < len(r.front); i++ {
a := attrs[i]
@@ -354,7 +340,7 @@ func (r *Record) addAttrs(attrs []log.KeyValue) {
}
// SetAttributes sets (and overrides) attributes to the log record.
-func (r *Record) SetAttributes(attrs ...log.KeyValue) {
+func (r *Record) SetAttributes(attrs ...attribute.KeyValue) {
var drop int
r.dropped = 0
if !r.allowDupKeys {
@@ -364,7 +350,7 @@ func (r *Record) SetAttributes(attrs ...log.KeyValue) {
}
}
- attrs, drop = head(attrs, r.attributeCountLimit)
+ attrs, drop = r.head(attrs)
r.addDropped(drop)
r.nFront = 0
@@ -381,17 +367,23 @@ func (r *Record) SetAttributes(attrs ...log.KeyValue) {
}
}
-// head returns the first n values of kvs along with the number of elements
-// dropped. If n is less than or equal to zero, kvs is returned with 0.
-func head(kvs []log.KeyValue, n int) (out []log.KeyValue, dropped int) {
- if n > 0 && len(kvs) > n {
- return kvs[:n], len(kvs) - n
+// head returns the attributes r can retain along with the number dropped.
+func (r *Record) head(kvs []attribute.KeyValue) (out []attribute.KeyValue, dropped int) {
+ if r.attributeCountLimit < 0 || len(kvs) <= r.attributeCountLimit {
+ return kvs, 0
+ }
+ if r.attributeCountLimit == 0 {
+ return nil, len(kvs)
}
- return kvs, 0
+ return kvs[:r.attributeCountLimit], len(kvs) - r.attributeCountLimit
+}
+
+func (r *Record) hasAttributeCountLimit() bool {
+ return r.attributeCountLimit >= 0
}
// dedup deduplicates kvs front-to-back with the last value saved.
-func dedup(kvs []log.KeyValue) (unique []log.KeyValue, dropped int) {
+func dedup(kvs []attribute.KeyValue) (unique []attribute.KeyValue, dropped int) {
if len(kvs) <= 1 {
return kvs, 0 // No deduplication needed.
}
@@ -415,7 +407,7 @@ func dedup(kvs []log.KeyValue) (unique []log.KeyValue, dropped int) {
return kvs, 0
}
- unique = make([]log.KeyValue, len(*u))
+ unique = make([]attribute.KeyValue, len(*u))
copy(unique, *u)
return unique, dropped
}
@@ -482,275 +474,14 @@ func (r *Record) Clone() Record {
return res
}
-func (r *Record) applyAttrLimitsAndDedup(attr log.KeyValue) log.KeyValue {
- attr.Value = r.applyValueLimitsAndDedup(attr.Value)
- return attr
-}
-
-func (r *Record) applyValueLimitsAndDedup(val log.Value) log.Value {
- switch val.Kind() {
- case log.KindString:
- s := val.AsString()
- if r.attributeValueLengthLimit >= 0 && len(s) > r.attributeValueLengthLimit {
- val = log.StringValue(truncate(r.attributeValueLengthLimit, s))
- }
- case log.KindSlice:
- sl := val.AsSlice()
-
- // First check if any limits need to be applied.
- if slices.ContainsFunc(sl, r.needsValueLimitsOrDedup) {
- // Create a new slice to avoid modifying the original.
- newSl := make([]log.Value, len(sl))
- for i, item := range sl {
- newSl[i] = r.applyValueLimitsAndDedup(item)
- }
- val = log.SliceValue(newSl...)
- }
- case log.KindBytes:
- bs := val.AsBytes()
- if r.attributeValueLengthLimit >= 0 && len(bs) > r.attributeValueLengthLimit {
- val = log.BytesValue(bs[:r.attributeValueLengthLimit])
- }
- case log.KindMap:
- kvs := val.AsMap()
- var newKvs []log.KeyValue
- var dropped int
-
- if !r.allowDupKeys {
- // Deduplicate then truncate.
- // Do not do at the same time to avoid wasted truncation operations.
- newKvs, dropped = dedup(kvs)
- if dropped > 0 {
- logKeyValuePairDropped()
- }
- } else {
- newKvs = kvs
- }
-
- // Check if any attribute limits need to be applied.
- needsChange := false
- if dropped > 0 {
- needsChange = true // Already changed by dedup.
- } else {
- for _, kv := range newKvs {
- if r.needsValueLimitsOrDedup(kv.Value) {
- needsChange = true
- break
- }
- }
- }
-
- if needsChange {
- // Only create new slice if changes are needed.
- if dropped == 0 {
- // Make a copy to avoid modifying the original.
- newKvs = make([]log.KeyValue, len(kvs))
- copy(newKvs, kvs)
- }
-
- for i := range newKvs {
- newKvs[i] = r.applyAttrLimitsAndDedup(newKvs[i])
- }
- val = log.MapValue(newKvs...)
- }
- }
- return val
-}
-
-// needsValueLimitsOrDedup checks if a value would be modified by applyValueLimitsAndDedup.
-func (r *Record) needsValueLimitsOrDedup(val log.Value) bool {
- switch val.Kind() {
- case log.KindString:
- return r.attributeValueLengthLimit >= 0 && len(val.AsString()) > r.attributeValueLengthLimit
- case log.KindSlice:
- if slices.ContainsFunc(val.AsSlice(), r.needsValueLimitsOrDedup) {
- return true
- }
- case log.KindBytes:
- bs := val.AsBytes()
- if r.attributeValueLengthLimit >= 0 && len(bs) > r.attributeValueLengthLimit {
- return true
- }
- case log.KindMap:
- kvs := val.AsMap()
- if !r.allowDupKeys && len(kvs) > 1 {
- // Check for duplicates.
- hasDuplicates := func() bool {
- seen := getSeen()
- defer putSeen(seen)
- for _, kv := range kvs {
- if _, ok := seen[kv.Key]; ok {
- return true
- }
- seen[kv.Key] = struct{}{}
- }
- return false
- }()
- if hasDuplicates {
- return true
- }
- }
- for _, kv := range kvs {
- if r.needsValueLimitsOrDedup(kv.Value) {
- return true
- }
- }
- }
- return false
-}
-
-func (r *Record) dedupeBodyCollections(val log.Value) log.Value {
- switch val.Kind() {
- case log.KindSlice:
- sl := val.AsSlice()
-
- // Check if any nested values need deduplication.
- if slices.ContainsFunc(sl, r.needsBodyDedup) {
- // Create a new slice to avoid modifying the original.
- newSl := make([]log.Value, len(sl))
- for i, item := range sl {
- newSl[i] = r.dedupeBodyCollections(item)
- }
- val = log.SliceValue(newSl...)
- }
-
- case log.KindMap:
- kvs := val.AsMap()
- newKvs, dropped := dedup(kvs)
-
- // Check if any nested values need deduplication.
- needsValueChange := false
- for _, kv := range newKvs {
- if r.needsBodyDedup(kv.Value) {
- needsValueChange = true
- break
- }
- }
-
- if dropped > 0 || needsValueChange {
- // Only create new value if changes are needed.
- if dropped == 0 {
- // Make a copy to avoid modifying the original.
- newKvs = make([]log.KeyValue, len(kvs))
- copy(newKvs, kvs)
- }
-
- for i := range newKvs {
- newKvs[i].Value = r.dedupeBodyCollections(newKvs[i].Value)
- }
- val = log.MapValue(newKvs...)
- }
- }
- return val
-}
-
-// needsBodyDedup checks if a value would be modified by dedupeBodyCollections.
-func (r *Record) needsBodyDedup(val log.Value) bool {
- switch val.Kind() {
- case log.KindSlice:
- if slices.ContainsFunc(val.AsSlice(), r.needsBodyDedup) {
- return true
- }
- case log.KindMap:
- kvs := val.AsMap()
- if len(kvs) > 1 {
- // Check for duplicates.
- hasDuplicates := func() bool {
- seen := getSeen()
- defer putSeen(seen)
- for _, kv := range kvs {
- if _, ok := seen[kv.Key]; ok {
- return true
- }
- seen[kv.Key] = struct{}{}
- }
- return false
- }()
- if hasDuplicates {
- return true
- }
- }
- for _, kv := range kvs {
- if r.needsBodyDedup(kv.Value) {
- return true
- }
- }
- }
- return false
-}
-
-// truncate returns a truncated version of s such that it contains less than
-// the limit number of characters. Truncation is applied by returning the limit
-// number of valid characters contained in s.
-//
-// If limit is negative, it returns the original string.
-//
-// UTF-8 is supported. When truncating, all invalid characters are dropped
-// before applying truncation.
-//
-// If s already contains less than the limit number of bytes, it is returned
-// unchanged. No invalid characters are removed.
-func truncate(limit int, s string) string {
- // This prioritize performance in the following order based on the most
- // common expected use-cases.
- //
- // - Short values less than the default limit (128).
- // - Strings with valid encodings that exceed the limit.
- // - No limit.
- // - Strings with invalid encodings that exceed the limit.
- if limit < 0 || len(s) <= limit {
- return s
- }
-
- // Optimistically, assume all valid UTF-8.
- var b strings.Builder
- count := 0
- for i, c := range s {
- if c != utf8.RuneError {
- count++
- if count > limit {
- return s[:i]
- }
- continue
- }
-
- _, size := utf8.DecodeRuneInString(s[i:])
- if size == 1 {
- // Invalid encoding.
- b.Grow(len(s) - 1)
- _, _ = b.WriteString(s[:i])
- s = s[i:]
- break
- }
- }
-
- // Fast-path, no invalid input.
- if b.Cap() == 0 {
- return s
- }
-
- // Truncate while validating UTF-8.
- for i := 0; i < len(s) && count < limit; {
- c := s[i]
- if c < utf8.RuneSelf {
- // Optimization for single byte runes (common case).
- _ = b.WriteByte(c)
- i++
- count++
- continue
- }
-
- _, size := utf8.DecodeRuneInString(s[i:])
- if size == 1 {
- // We checked for all 1-byte runes above, this is a RuneError.
- i++
- continue
+func (r *Record) applyAttrLimitsAndDedup(attr attribute.KeyValue) attribute.KeyValue {
+ if !r.allowDupKeys {
+ var changed bool
+ attr, changed = attrnorm.KeyValue(attr)
+ if changed {
+ logKeyValuePairDropped()
}
-
- _, _ = b.WriteString(s[i : i+size])
- i += size
- count++
}
-
- return b.String()
+ attr.Value = attrnorm.TruncateValue(r.attributeValueLengthLimit, attr.Value)
+ return attr
}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/ring.go b/vendor/go.opentelemetry.io/otel/sdk/log/ring.go
index 5e84cb164..95da3816c 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/ring.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/ring.go
@@ -5,7 +5,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
// A ring is an element of a circular list, or ring. Rings do not have a
// beginning or end; a pointer to any ring element serves as reference to the
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/setting.go b/vendor/go.opentelemetry.io/otel/sdk/log/setting.go
index 72107a9e5..eb232bcb2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/setting.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/setting.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"fmt"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/log/simple.go b/vendor/go.opentelemetry.io/otel/sdk/log/simple.go
index 9772e0c5e..ab83f19a2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/log/simple.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/log/simple.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package log // import "go.opentelemetry.io/otel/sdk/log"
+package log
import (
"context"
@@ -80,13 +80,13 @@ func (s *SimpleProcessor) OnEmit(ctx context.Context, r *Record) (err error) {
return s.exporter.Export(ctx, *records)
}
-// Shutdown shuts down the exporter.
+// Shutdown flushes the exporter before shutting it down.
func (s *SimpleProcessor) Shutdown(ctx context.Context) error {
if s.exporter == nil {
return nil
}
- return s.exporter.Shutdown(ctx)
+ return shutdownExporter(ctx, s.exporter)
}
// ForceFlush flushes the exporter.
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/auto.go b/vendor/go.opentelemetry.io/otel/sdk/resource/auto.go
index c02aeefdd..8754313af 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/auto.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/auto.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/builtin.go b/vendor/go.opentelemetry.io/otel/sdk/resource/builtin.go
index 28823edd5..d5f6dc0a6 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/builtin.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/builtin.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
@@ -13,7 +13,7 @@ import (
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/sdk"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
type (
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/config.go b/vendor/go.opentelemetry.io/otel/sdk/resource/config.go
index a3d647d92..c5ffa45d0 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/config.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/config.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
@@ -23,7 +23,9 @@ type Option interface {
apply(config) config
}
-// WithAttributes adds attributes to the configured Resource.
+// WithAttributes adds attributes to the configured Resource. Duplicate
+// top-level attribute keys and duplicate keys inside map values are
+// resolved using last-value-wins semantics.
func WithAttributes(attributes ...attribute.KeyValue) Option {
return WithDetectors(detectAttributes{attributes})
}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/container.go b/vendor/go.opentelemetry.io/otel/sdk/resource/container.go
index ce03e24c4..c81163bf8 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/container.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/container.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"bufio"
@@ -11,7 +11,7 @@ import (
"os"
"regexp"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
type containerIDProvider func() (string, error)
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/doc.go b/vendor/go.opentelemetry.io/otel/sdk/resource/doc.go
index 64939a271..f5a79d3fe 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/doc.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/doc.go
@@ -17,4 +17,4 @@
//
// While this package provides a stable API,
// the attributes added by resource detectors may change.
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/env.go b/vendor/go.opentelemetry.io/otel/sdk/resource/env.go
index ac5691c08..0eeb1e2ae 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/env.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/env.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
@@ -12,7 +12,7 @@ import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
const (
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id.go
index cb38fa1a8..47219be22 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id.go
@@ -1,14 +1,14 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
"errors"
"strings"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
type hostIDProvider func() (string, error)
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_bsd.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_bsd.go
index 4c1c30f25..bcd174342 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_bsd.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_bsd.go
@@ -3,7 +3,7 @@
//go:build dragonfly || freebsd || netbsd || openbsd || solaris
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
var platformHostIDReader hostIDReader = &hostIDReaderBSD{
execCommand: execCommand,
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_darwin.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_darwin.go
index b09fde3b7..81ece5b34 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_darwin.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_darwin.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
var platformHostIDReader hostIDReader = &hostIDReaderDarwin{
execCommand: execCommand,
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_exec.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_exec.go
index e239ead02..c058f0d26 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_exec.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_exec.go
@@ -3,7 +3,7 @@
//go:build darwin || dragonfly || freebsd || netbsd || openbsd || solaris
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_linux.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_linux.go
index 4a26096c8..26cf6a5d1 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_linux.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_linux.go
@@ -3,7 +3,7 @@
//go:build linux
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
var platformHostIDReader hostIDReader = &hostIDReaderLinux{
readFile: readFile,
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_readfile.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_readfile.go
index c95d87685..d955c2c90 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_readfile.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_readfile.go
@@ -3,7 +3,7 @@
//go:build linux || dragonfly || freebsd || netbsd || openbsd || solaris
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import "os"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_unsupported.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_unsupported.go
index 63ad2fa4e..9f6ca8211 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_unsupported.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_unsupported.go
@@ -3,7 +3,7 @@
//go:build !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
// hostIDReaderUnsupported is a placeholder implementation for operating systems
// for which this project currently doesn't support host.id
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_windows.go b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_windows.go
index 2b8ca20b3..e9e4a0384 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_windows.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/host_id_windows.go
@@ -3,7 +3,7 @@
//go:build windows
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"golang.org/x/sys/windows/registry"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/os.go b/vendor/go.opentelemetry.io/otel/sdk/resource/os.go
index 4c0def414..6af491567 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/os.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/os.go
@@ -1,14 +1,14 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
"strings"
"go.opentelemetry.io/otel/attribute"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
type osDescriptionProvider func() (string, error)
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_darwin.go b/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_darwin.go
index 3d703c5d9..f12876d17 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_darwin.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_darwin.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"encoding/xml"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_unix.go b/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_unix.go
index a1763267c..ad9285854 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_unix.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/os_release_unix.go
@@ -3,7 +3,7 @@
//go:build aix || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"bufio"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/os_unix.go b/vendor/go.opentelemetry.io/otel/sdk/resource/os_unix.go
index 1cd87c398..ba5e48db2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/os_unix.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/os_unix.go
@@ -3,7 +3,7 @@
//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"fmt"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/os_unsupported.go b/vendor/go.opentelemetry.io/otel/sdk/resource/os_unsupported.go
index 25f629532..e2c19c2b3 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/os_unsupported.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/os_unsupported.go
@@ -3,7 +3,7 @@
//go:build !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
// platformOSDescription is a placeholder implementation for OSes
// for which this project currently doesn't support os.description
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/os_windows.go b/vendor/go.opentelemetry.io/otel/sdk/resource/os_windows.go
index ebd50826d..9b7648957 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/os_windows.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/os_windows.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"fmt"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/process.go b/vendor/go.opentelemetry.io/otel/sdk/resource/process.go
index b015f8233..a578fc325 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/process.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/process.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
@@ -11,7 +11,7 @@ import (
"path/filepath"
"runtime"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
)
type (
diff --git a/vendor/go.opentelemetry.io/otel/sdk/resource/resource.go b/vendor/go.opentelemetry.io/otel/sdk/resource/resource.go
index f715be53e..68ab274d2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/resource.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/resource.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package resource // import "go.opentelemetry.io/otel/sdk/resource"
+package resource
import (
"context"
@@ -11,6 +11,7 @@ import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
+ "go.opentelemetry.io/otel/sdk/internal/attrnorm"
"go.opentelemetry.io/otel/sdk/internal/x"
)
@@ -47,6 +48,8 @@ var (
var ErrSchemaURLConflict = errors.New("conflicting Schema URL")
// New returns a [Resource] built using opts.
+// Duplicate top-level attribute keys and duplicate keys inside map
+// values are resolved using last-value-wins semantics.
//
// This may return a partial Resource along with an error containing
// [ErrPartialResource] if options that provide a [Detector] are used and that
@@ -66,25 +69,29 @@ func New(ctx context.Context, opts ...Option) (*Resource, error) {
return r, detect(ctx, r, cfg.detectors)
}
-// NewWithAttributes creates a resource from attrs and associates the resource with a
-// schema URL. If attrs contains duplicate keys, the last value will be used. If attrs
-// contains any invalid items those items will be dropped. The attrs are assumed to be
-// in a schema identified by schemaURL.
+// NewWithAttributes creates a resource from attrs and associates the resource
+// with a schema URL. If attrs contains duplicate top-level attribute keys or
+// duplicate keys inside map values, the last value will be used. If attrs
+// contains any invalid items those items will be dropped. The attrs are assumed
+// to be in a schema identified by schemaURL.
func NewWithAttributes(schemaURL string, attrs ...attribute.KeyValue) *Resource {
resource := NewSchemaless(attrs...)
resource.schemaURL = schemaURL
return resource
}
-// NewSchemaless creates a resource from attrs. If attrs contains duplicate keys,
-// the last value will be used. If attrs contains any invalid items those items will
-// be dropped. The resource will not be associated with a schema URL. If the schema
+// NewSchemaless creates a resource from attrs. If attrs contains duplicate
+// top-level attribute keys or duplicate keys inside map values, the last
+// value will be used. If attrs contains any invalid items those items will be
+// dropped. The resource will not be associated with a schema URL. If the schema
// of the attrs is known use NewWithAttributes instead.
func NewSchemaless(attrs ...attribute.KeyValue) *Resource {
if len(attrs) == 0 {
return &Resource{}
}
+ attrs, _ = attrnorm.KeyValues(attrs)
+
// Ensure attributes comply with the specification:
// https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/common/README.md#attribute
s, _ := attribute.NewSetWithFiltered(attrs, func(kv attribute.KeyValue) bool {
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go b/vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go
index f9f2a6c2c..2b9560ee7 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go
@@ -1,11 +1,12 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
"errors"
+ "fmt"
"sync"
"sync/atomic"
"time"
@@ -435,11 +436,11 @@ func (bsp *batchSpanProcessor) enqueueDrop(ctx context.Context, sd ReadOnlySpan)
func (bsp *batchSpanProcessor) MarshalLog() any {
return struct {
Type string
- SpanExporter SpanExporter
+ SpanExporter string
Config BatchSpanProcessorOptions
}{
Type: "BatchSpanProcessor",
- SpanExporter: bsp.e,
+ SpanExporter: fmt.Sprintf("%T", bsp.e),
Config: bsp.o,
}
}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/doc.go b/vendor/go.opentelemetry.io/otel/sdk/trace/doc.go
index b502c7d47..b292fa311 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/doc.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/doc.go
@@ -10,4 +10,4 @@ See https://opentelemetry.io.
See [go.opentelemetry.io/otel/sdk/internal/x] for information about
the experimental features.
*/
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/event.go b/vendor/go.opentelemetry.io/otel/sdk/trace/event.go
index 60a7ed134..49eac0459 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/event.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/event.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"time"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go b/vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go
index 8c308dd60..1f62b528c 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"slices"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/id_generator.go b/vendor/go.opentelemetry.io/otel/sdk/trace/id_generator.go
index 3649322a6..be22ac632 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/id_generator.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/id_generator.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/env/env.go b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/env/env.go
index 58f68df44..1385ae6fc 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/env/env.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/env/env.go
@@ -3,7 +3,7 @@
// Package env provides types and functionality for environment variable support
// in the OpenTelemetry SDK.
-package env // import "go.opentelemetry.io/otel/sdk/trace/internal/env"
+package env
import (
"os"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/batch_span_processor.go b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/batch_span_processor.go
index c725ebf37..896ed517f 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/batch_span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/batch_span_processor.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/sdk/trace/internal/observ"
+package observ
import (
"context"
@@ -13,8 +13,8 @@ import (
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/sdk"
"go.opentelemetry.io/otel/sdk/internal/x"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
const (
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/doc.go b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/doc.go
index b542121e6..64fd5238d 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/doc.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/doc.go
@@ -3,4 +3,4 @@
// Package observ provides observability instrumentation for the OTel trace SDK
// package.
-package observ // import "go.opentelemetry.io/otel/sdk/trace/internal/observ"
+package observ
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/simple_span_processor.go b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/simple_span_processor.go
index cf4b5d481..89922e4b8 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/simple_span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/simple_span_processor.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/sdk/trace/internal/observ"
+package observ
import (
"context"
@@ -13,8 +13,8 @@ import (
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/sdk"
"go.opentelemetry.io/otel/sdk/internal/x"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
)
var measureAttrsPool = sync.Pool{
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/tracer.go b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/tracer.go
index 5aae89e88..3428aa894 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/tracer.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/internal/observ/tracer.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package observ // import "go.opentelemetry.io/otel/sdk/trace/internal/observ"
+package observ
import (
"context"
@@ -13,7 +13,7 @@ import (
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/sdk"
"go.opentelemetry.io/otel/sdk/internal/x"
- "go.opentelemetry.io/otel/semconv/v1.41.0/otelconv"
+ "go.opentelemetry.io/otel/semconv/v1.43.0/otelconv"
"go.opentelemetry.io/otel/trace"
)
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/link.go b/vendor/go.opentelemetry.io/otel/sdk/trace/link.go
index c03bdc90f..d4a07a714 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/link.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/link.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/provider.go b/vendor/go.opentelemetry.io/otel/sdk/trace/provider.go
index 9d90c2eda..6b2368413 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/provider.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/provider.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
@@ -13,6 +13,7 @@ import (
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/internal/global"
"go.opentelemetry.io/otel/sdk/instrumentation"
+ "go.opentelemetry.io/otel/sdk/internal/attrnorm"
"go.opentelemetry.io/otel/sdk/resource"
"go.opentelemetry.io/otel/sdk/trace/internal/observ"
"go.opentelemetry.io/otel/trace"
@@ -42,22 +43,27 @@ type tracerProviderConfig struct {
// resource contains attributes representing an entity that produces telemetry.
resource *resource.Resource
+
+ // panicRecordingDisabled disables recording exception events from panics.
+ panicRecordingDisabled bool
}
// MarshalLog is the marshaling function used by the logging system to represent this Provider.
func (cfg tracerProviderConfig) MarshalLog() any {
return struct {
- SpanProcessors []SpanProcessor
- SamplerType string
- IDGeneratorType string
- SpanLimits SpanLimits
- Resource *resource.Resource
+ SpanProcessors []SpanProcessor
+ SamplerType string
+ IDGeneratorType string
+ SpanLimits SpanLimits
+ Resource *resource.Resource
+ PanicRecordingDisabled bool
}{
- SpanProcessors: cfg.processors,
- SamplerType: fmt.Sprintf("%T", cfg.sampler),
- IDGeneratorType: fmt.Sprintf("%T", cfg.idGenerator),
- SpanLimits: cfg.spanLimits,
- Resource: cfg.resource,
+ SpanProcessors: cfg.processors,
+ SamplerType: fmt.Sprintf("%T", cfg.sampler),
+ IDGeneratorType: fmt.Sprintf("%T", cfg.idGenerator),
+ SpanLimits: cfg.spanLimits,
+ Resource: cfg.resource,
+ PanicRecordingDisabled: cfg.panicRecordingDisabled,
}
}
@@ -74,10 +80,11 @@ type TracerProvider struct {
// These fields are not protected by the lock mu. They are assumed to be
// immutable after creation of the TracerProvider.
- sampler Sampler
- idGenerator IDGenerator
- spanLimits SpanLimits
- resource *resource.Resource
+ sampler Sampler
+ idGenerator IDGenerator
+ spanLimits SpanLimits
+ resource *resource.Resource
+ panicRecordingDisabled bool
}
var _ trace.TracerProvider = &TracerProvider{}
@@ -112,11 +119,12 @@ func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider {
o = ensureValidTracerProviderConfig(o)
tp := &TracerProvider{
- namedTracer: make(map[instrumentation.Scope]*tracer),
- sampler: o.sampler,
- idGenerator: o.idGenerator,
- spanLimits: o.spanLimits,
- resource: o.resource,
+ namedTracer: make(map[instrumentation.Scope]*tracer),
+ sampler: o.sampler,
+ idGenerator: o.idGenerator,
+ spanLimits: o.spanLimits,
+ resource: o.resource,
+ panicRecordingDisabled: o.panicRecordingDisabled,
}
global.Info("TracerProvider created", "config", o)
@@ -142,6 +150,7 @@ func (p *TracerProvider) Tracer(name string, opts ...trace.TracerOption) trace.T
return noop.NewTracerProvider().Tracer(name, opts...)
}
c := trace.NewTracerConfig(opts...)
+ attrs, _ := attrnorm.Set(c.InstrumentationAttributes())
if name == "" {
name = defaultTracerName
}
@@ -149,7 +158,7 @@ func (p *TracerProvider) Tracer(name string, opts ...trace.TracerOption) trace.T
Name: name,
Version: c.InstrumentationVersion(),
SchemaURL: c.SchemaURL(),
- Attributes: c.InstrumentationAttributes(),
+ Attributes: attrs,
}
t, ok := func() (trace.Tracer, bool) {
@@ -357,6 +366,16 @@ func WithSpanProcessor(sp SpanProcessor) TracerProviderOption {
})
}
+// WithoutPanicRecording configures the TracerProvider to not record exception
+// events when a Span is ended while panicking. The panic continues to
+// propagate, and the span is ended without adding the event.
+func WithoutPanicRecording() TracerProviderOption {
+ return traceProviderOptionFunc(func(cfg tracerProviderConfig) tracerProviderConfig {
+ cfg.panicRecordingDisabled = true
+ return cfg
+ })
+}
+
// WithResource returns a TracerProviderOption that will configure the
// Resource r as a TracerProvider's Resource. The configured Resource is
// referenced by all the Tracers the TracerProvider creates. It represents the
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/sampler_env.go b/vendor/go.opentelemetry.io/otel/sdk/trace/sampler_env.go
index 9b672a1d7..b0fa94ed2 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/sampler_env.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/sampler_env.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"errors"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go b/vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go
index 5a4c74318..c79177ae8 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go b/vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go
index 771e427a4..e9bec4394 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go
@@ -1,10 +1,11 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
+ "fmt"
"sync"
"sync/atomic"
@@ -140,11 +141,18 @@ func (*simpleSpanProcessor) ForceFlush(context.Context) error {
// MarshalLog is the marshaling function used by the logging system to represent
// this Span Processor.
func (ssp *simpleSpanProcessor) MarshalLog() any {
+ // Shutdown clears exporter under exporterMu.
+ // Copy it while holding the same lock so MarshalLog
+ // can run concurrently without racing with Shutdown.
+ ssp.exporterMu.Lock()
+ exp := ssp.exporter
+ ssp.exporterMu.Unlock()
+
return struct {
Type string
- Exporter SpanExporter
+ Exporter string
}{
Type: "SimpleSpanProcessor",
- Exporter: ssp.exporter,
+ Exporter: fmt.Sprintf("%T", exp),
}
}
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/snapshot.go b/vendor/go.opentelemetry.io/otel/sdk/trace/snapshot.go
index 63aa33780..8893dc39f 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/snapshot.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/snapshot.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"time"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/span.go b/vendor/go.opentelemetry.io/otel/sdk/trace/span.go
index d1d9af29d..0aae5f5bb 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/span.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/span.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
@@ -10,17 +10,16 @@ import (
"runtime"
rt "runtime/trace"
"slices"
- "strings"
"sync"
"time"
- "unicode/utf8"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/internal/global"
"go.opentelemetry.io/otel/sdk/instrumentation"
+ "go.opentelemetry.io/otel/sdk/internal/attrnorm"
"go.opentelemetry.io/otel/sdk/resource"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
"go.opentelemetry.io/otel/trace"
"go.opentelemetry.io/otel/trace/embedded"
)
@@ -269,7 +268,8 @@ func (s *recordingSpan) SetAttributes(attributes ...attribute.KeyValue) {
s.addDroppedAttr(1)
continue
}
- a = truncateAttr(s.tracer.provider.spanLimits.AttributeValueLengthLimit, a)
+ a = dedupAttr(a)
+ a = attrnorm.Truncate(s.tracer.provider.spanLimits.AttributeValueLengthLimit, a)
s.attributes = append(s.attributes, a)
}
}
@@ -329,7 +329,8 @@ func (s *recordingSpan) addOverCapAttrs(limit int, attrs []attribute.KeyValue) {
if idx, ok := exists[a.Key]; ok {
// Perform all updates before dropping, even when at capacity.
- a = truncateAttr(s.tracer.provider.spanLimits.AttributeValueLengthLimit, a)
+ a = dedupAttr(a)
+ a = attrnorm.Truncate(s.tracer.provider.spanLimits.AttributeValueLengthLimit, a)
s.attributes[idx] = a
continue
}
@@ -339,208 +340,31 @@ func (s *recordingSpan) addOverCapAttrs(limit int, attrs []attribute.KeyValue) {
// updates are checked and performed.
s.addDroppedAttr(1)
} else {
- a = truncateAttr(s.tracer.provider.spanLimits.AttributeValueLengthLimit, a)
+ a = dedupAttr(a)
+ a = attrnorm.Truncate(s.tracer.provider.spanLimits.AttributeValueLengthLimit, a)
s.attributes = append(s.attributes, a)
exists[a.Key] = len(s.attributes) - 1
}
}
}
-// truncateAttr returns a truncated version of attr. Only string, string
-// slice, byte slice, and slice attribute values are truncated. String values are truncated
-// to at most a length of limit. Each string slice value is truncated in this
-// fashion (the slice length itself is unaffected), and byte slice values are truncated to at most
-// limit bytes. For slice attribute values, the limit is applied to each
-// element recursively.
-//
-// No truncation is performed for a negative limit.
-func truncateAttr(limit int, attr attribute.KeyValue) attribute.KeyValue {
- if limit < 0 {
- return attr
- }
+func dedupAttr(attr attribute.KeyValue) attribute.KeyValue {
switch attr.Value.Type() {
- case attribute.STRING:
- v := attr.Value.AsString()
- return attr.Key.String(truncate(limit, v))
- case attribute.STRINGSLICE:
- v := attr.Value.AsStringSlice()
- for i := range v {
- v[i] = truncate(limit, v[i])
- }
- return attr.Key.StringSlice(v)
- case attribute.BYTESLICE:
- v := attr.Value.AsString()
- if len(v) > limit {
- return attr.Key.ByteSlice([]byte(v[:limit]))
- }
+ case attribute.SLICE, attribute.MAP:
+ attr, _ = attrnorm.KeyValue(attr)
+ return attr
+ default:
return attr
- case attribute.SLICE:
- v := attr.Value.AsSlice()
- if !slices.ContainsFunc(v, func(e attribute.Value) bool { return needsTruncation(limit, e) }) {
- return attr
- }
- newV := make([]attribute.Value, len(v))
- for i, elem := range v {
- newV[i] = truncateValue(limit, elem)
- }
- return attr.Key.Slice(newV...)
- }
- return attr
-}
-
-// truncateValue returns a truncated version of v. Only string, string slice,
-// byte slice, and (recursively) slice values are modified.
-//
-// No truncation is performed for a negative limit.
-func truncateValue(limit int, v attribute.Value) attribute.Value {
- switch v.Type() {
- case attribute.STRING:
- return attribute.StringValue(truncate(limit, v.AsString()))
- case attribute.STRINGSLICE:
- ss := v.AsStringSlice()
- for i := range ss {
- ss[i] = truncate(limit, ss[i])
- }
- return attribute.StringSliceValue(ss)
-
- case attribute.BYTESLICE:
- // len(v.AsString()) is identical to len(v.AsByteSlice()) but
- // avoids allocating the full slice before truncation.
- s := v.AsString()
- if limit >= 0 && len(s) > limit {
- return attribute.ByteSliceValue([]byte(s[:limit]))
- }
- case attribute.SLICE:
- sl := v.AsSlice()
- if !slices.ContainsFunc(sl, func(e attribute.Value) bool { return needsTruncation(limit, e) }) {
- return v
- }
- newSl := make([]attribute.Value, len(sl))
- for i, elem := range sl {
- newSl[i] = truncateValue(limit, elem)
- }
- return attribute.SliceValue(newSl...)
- }
- return v
-}
-
-// stringNeedsTruncation reports whether s would be modified by truncate for the
-// given limit.
-func stringNeedsTruncation(limit int, s string) bool {
- if limit < 0 || len(s) <= limit {
- return false
- }
- return utf8.RuneCountInString(s) > limit || !utf8.ValidString(s)
-}
-
-// needsTruncation reports whether v would be modified by truncateValue for the
-// given limit.
-func needsTruncation(limit int, v attribute.Value) bool {
- switch v.Type() {
- case attribute.STRING:
- return stringNeedsTruncation(limit, v.AsString())
- case attribute.BYTESLICE:
- // len(v.AsString()) is identical to len(v.AsByteSlice()) but
- // avoids memory allocation.
- if limit >= 0 && len(v.AsString()) > limit {
- return true
- }
- case attribute.STRINGSLICE:
- for _, s := range v.AsStringSlice() {
- if stringNeedsTruncation(limit, s) {
- return true
- }
- }
- case attribute.SLICE:
- return slices.ContainsFunc(v.AsSlice(), func(e attribute.Value) bool { return needsTruncation(limit, e) })
- }
- return false
-}
-
-// truncate returns a truncated version of s such that it contains less than
-// the limit number of characters. Truncation is applied by returning the limit
-// number of valid characters contained in s.
-//
-// If limit is negative, it returns the original string.
-//
-// UTF-8 is supported. When truncating, all invalid characters are dropped
-// before applying truncation.
-//
-// If s already contains less than the limit number of bytes, it is returned
-// unchanged. No invalid characters are removed.
-func truncate(limit int, s string) string {
- // This prioritize performance in the following order based on the most
- // common expected use-cases.
- //
- // - Short values less than the default limit (128).
- // - Strings with valid encodings that exceed the limit.
- // - No limit.
- // - Strings with invalid encodings that exceed the limit.
- if limit < 0 || len(s) <= limit {
- return s
- }
-
- // Optimistically, assume all valid UTF-8.
- var b strings.Builder
- count := 0
- for i, c := range s {
- if c != utf8.RuneError {
- count++
- if count > limit {
- return s[:i]
- }
- continue
- }
-
- _, size := utf8.DecodeRuneInString(s[i:])
- if size == 1 {
- // Invalid encoding.
- b.Grow(len(s) - 1)
- _, _ = b.WriteString(s[:i])
- s = s[i:]
- break
- }
- }
-
- // Fast-path, no invalid input.
- if b.Cap() == 0 {
- return s
- }
-
- // Truncate while validating UTF-8.
- for i := 0; i < len(s) && count < limit; {
- c := s[i]
- if c < utf8.RuneSelf {
- // Optimization for single byte runes (common case).
- _ = b.WriteByte(c)
- i++
- count++
- continue
- }
-
- _, size := utf8.DecodeRuneInString(s[i:])
- if size == 1 {
- // We checked for all 1-byte runes above, this is a RuneError.
- i++
- continue
- }
-
- _, _ = b.WriteString(s[i : i+size])
- i += size
- count++
}
-
- return b.String()
}
// End ends the span. This method does nothing if the span is already ended or
// is not being recorded.
//
-// The only SpanEndOption currently supported are [trace.WithTimestamp], and
-// [trace.WithStackTrace].
-//
-// If this method is called while panicking an error event is added to the
-// Span before ending it and the panic is continued.
+// The only supported SpanEndOptions are [trace.WithTimestamp] and [trace.WithStackTrace].
+// If this method is called while panicking and panic recording is not disabled
+// on the TracerProvider, an error event is added to the Span before ending it
+// and the panic is continued.
func (s *recordingSpan) End(options ...trace.SpanEndOption) {
// Do not start by checking if the span is being recorded which requires
// acquiring a lock. Make a minimal check that the span is not nil.
@@ -560,23 +384,25 @@ func (s *recordingSpan) End(options ...trace.SpanEndOption) {
}
config := trace.NewSpanEndConfig(options...)
- if recovered := recover(); recovered != nil {
- // Record but don't stop the panic.
- defer panic(recovered)
- opts := []trace.EventOption{
- trace.WithAttributes(
- semconv.ExceptionType(typeStr(recovered)),
- semconv.ExceptionMessage(fmt.Sprint(recovered)),
- ),
- }
+ if !s.tracer.provider.panicRecordingDisabled {
+ if recovered := recover(); recovered != nil {
+ // Record but don't stop the panic.
+ defer panic(recovered)
+ opts := []trace.EventOption{
+ trace.WithAttributes(
+ semconv.ExceptionType(typeStr(recovered)),
+ semconv.ExceptionMessage(fmt.Sprint(recovered)),
+ ),
+ }
- if config.StackTrace() {
- opts = append(opts, trace.WithAttributes(
- semconv.ExceptionStacktrace(recordStackTrace()),
- ))
- }
+ if config.StackTrace() {
+ opts = append(opts, trace.WithAttributes(
+ semconv.ExceptionStacktrace(recordStackTrace()),
+ ))
+ }
- s.addEvent(semconv.ExceptionEventName, opts...)
+ s.addEvent(semconv.ExceptionEventName, opts...)
+ }
}
if s.executionTracerTaskEnd != nil {
@@ -690,7 +516,8 @@ func (s *recordingSpan) AddEvent(name string, o ...trace.EventOption) {
// This method assumes s.mu.Lock is held by the caller.
func (s *recordingSpan) addEvent(name string, o ...trace.EventOption) {
c := trace.NewEventConfig(o...)
- e := Event{Name: name, Attributes: c.Attributes(), Time: c.Timestamp()}
+ attrs, _ := attrnorm.KeyValues(c.Attributes())
+ e := Event{Name: name, Attributes: attrs, Time: c.Timestamp()}
// Discard attributes over limit.
limit := s.tracer.provider.spanLimits.AttributePerEventCountLimit
@@ -863,7 +690,8 @@ func (s *recordingSpan) AddLink(link trace.Link) {
return
}
- l := Link{SpanContext: link.SpanContext, Attributes: link.Attributes}
+ attrs, _ := attrnorm.KeyValues(link.Attributes)
+ l := Link{SpanContext: link.SpanContext, Attributes: attrs}
// Discard attributes over limit.
limit := s.tracer.provider.spanLimits.AttributePerLinkCountLimit
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/span_exporter.go b/vendor/go.opentelemetry.io/otel/sdk/trace/span_exporter.go
index 6bdda3d94..fad839a24 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/span_exporter.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/span_exporter.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import "context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/span_limits.go b/vendor/go.opentelemetry.io/otel/sdk/trace/span_limits.go
index 348ee0e80..5ee15a884 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/span_limits.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/span_limits.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import "go.opentelemetry.io/otel/sdk/trace/internal/env"
@@ -35,10 +35,10 @@ const (
type SpanLimits struct {
// AttributeValueLengthLimit is the maximum allowed attribute value length.
//
- // This limit only applies to string, string slice, byte slice, and slice attribute
- // values. Any string and byte slice longer than this value will be truncated to this
- // length. For slice attribute values, the limit is applied to each string and byte slice
- // element recursively.
+ // This limit only applies to string, string slice, byte slice, slice, and
+ // map attribute values. Any string and byte slice longer than this value
+ // will be truncated to this length. For slice and map attribute values,
+ // the limit is applied recursively to contained values.
//
// Setting this to a negative value means no limit is applied.
AttributeValueLengthLimit int
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/span_processor.go b/vendor/go.opentelemetry.io/otel/sdk/trace/span_processor.go
index af7f9177f..ffd093a2f 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/span_processor.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go b/vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go
index e1d08fd4d..be576ffe0 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/sdk/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/sdk/version.go b/vendor/go.opentelemetry.io/otel/sdk/version.go
index 218dce1f5..1619fb3fa 100644
--- a/vendor/go.opentelemetry.io/otel/sdk/version.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/version.go
@@ -2,9 +2,9 @@
// SPDX-License-Identifier: Apache-2.0
// Package sdk provides the OpenTelemetry default SDK for Go.
-package sdk // import "go.opentelemetry.io/otel/sdk"
+package sdk
// Version is the current release version of the OpenTelemetry SDK in use.
func Version() string {
- return "1.44.0"
+ return "1.45.0"
}
diff --git a/vendor/go.opentelemetry.io/otel/semconv/internal/metricpool/pool.go b/vendor/go.opentelemetry.io/otel/semconv/internal/metricpool/pool.go
new file mode 100644
index 000000000..c5f5ad46e
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/semconv/internal/metricpool/pool.go
@@ -0,0 +1,48 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package metricpool provides shared pools for semantic convention metric
+// measurement options.
+package metricpool
+
+import (
+ "sync"
+
+ "go.opentelemetry.io/otel/metric"
+)
+
+var (
+ addOptionsPool = sync.Pool{New: func() any {
+ o := make([]metric.AddOption, 0, 1)
+ return &o
+ }}
+ recOptionsPool = sync.Pool{New: func() any {
+ o := make([]metric.RecordOption, 0, 1)
+ return &o
+ }}
+)
+
+// AddOptions returns a pooled AddOption slice.
+func AddOptions() *[]metric.AddOption {
+ return addOptionsPool.Get().(*[]metric.AddOption)
+}
+
+// PutAddOptions clears, resets, and returns o to the shared AddOption pool.
+func PutAddOptions(o *[]metric.AddOption) {
+ clear(*o)
+ *o = (*o)[:0]
+ addOptionsPool.Put(o)
+}
+
+// RecordOptions returns a pooled RecordOption slice.
+func RecordOptions() *[]metric.RecordOption {
+ return recOptionsPool.Get().(*[]metric.RecordOption)
+}
+
+// PutRecordOptions clears, resets, and returns o to the shared RecordOption
+// pool.
+func PutRecordOptions(o *[]metric.RecordOption) {
+ clear(*o)
+ *o = (*o)[:0]
+ recOptionsPool.Put(o)
+}
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/doc.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/doc.go
index e087c9c04..9c5322697 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/doc.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/doc.go
@@ -6,4 +6,4 @@
// OpenTelemetry semantic conventions are agreed standardized naming
// patterns for OpenTelemetry things. This package represents the conventions
// as of the v1.17.0 version of the OpenTelemetry specification.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/event.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/event.go
index c7b804bbe..20b495e5a 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/event.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/event.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
import "go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/exception.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/exception.go
index 137acc67d..3fe84aae0 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/exception.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/exception.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
const (
// ExceptionEventName is the name of the Span event representing an exception.
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/http.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/http.go
index d318221e5..5f6a66586 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/http.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/http.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
// HTTP scheme attributes.
var (
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/resource.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/resource.go
index 7e365e82c..7bc9c6db2 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/resource.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/resource.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
import "go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/schema.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/schema.go
index 634a1dce0..e0310defe 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/schema.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/schema.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
// SchemaURL is the schema URL that matches the version of the semantic conventions
// that this package defines. Semconv packages starting from v1.4.0 must declare
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/trace.go b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/trace.go
index 21497bb6b..9203e8280 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/trace.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.17.0/trace.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.17.0"
+package semconv
import "go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/attribute_group.go b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/attribute_group.go
index d147761f8..b3b2815bd 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/attribute_group.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/attribute_group.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.26.0"
+package semconv
import "go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/doc.go b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/doc.go
index d031bbea7..566b9a209 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/doc.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/doc.go
@@ -6,4 +6,4 @@
// OpenTelemetry semantic conventions are agreed standardized naming
// patterns for OpenTelemetry things. This package represents the v1.26.0
// version of the OpenTelemetry semantic conventions.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.26.0"
+package semconv
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/exception.go b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/exception.go
index bfaee0d56..3fe84aae0 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/exception.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/exception.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.26.0"
+package semconv
const (
// ExceptionEventName is the name of the Span event representing an exception.
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/metric.go
index fcdb9f485..9f2ce7880 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/metric.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/metric.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.26.0"
+package semconv
const (
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/schema.go b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/schema.go
index 4c87c7adc..7f0b72cef 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/schema.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.26.0/schema.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.26.0"
+package semconv
// SchemaURL is the schema URL that matches the version of the semantic conventions
// that this package defines. Semconv packages starting from v1.4.0 must declare
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/attribute_group.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/attribute_group.go
index 2fcab2435..d20ad49ef 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/attribute_group.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/attribute_group.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.37.0"
+package semconv
import "go.opentelemetry.io/otel/attribute"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/doc.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/doc.go
index 111010321..b67c64b96 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/doc.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/doc.go
@@ -6,4 +6,4 @@
// OpenTelemetry semantic conventions are agreed standardized naming
// patterns for OpenTelemetry things. This package represents the v1.37.0
// version of the OpenTelemetry semantic conventions.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.37.0"
+package semconv
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/error_type.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/error_type.go
index 267979c05..719241429 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/error_type.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/error_type.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.37.0"
+package semconv
import (
"reflect"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/exception.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/exception.go
index e67469a4f..3fe84aae0 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/exception.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/exception.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.37.0"
+package semconv
const (
// ExceptionEventName is the name of the Span event representing an exception.
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/schema.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/schema.go
index f8a0b7044..0009b185b 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/schema.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/schema.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.37.0"
+package semconv
// SchemaURL is the schema URL that matches the version of the semantic conventions
// that this package defines. Semconv packages starting from v1.4.0 must declare
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/MIGRATION.md b/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/MIGRATION.md
deleted file mode 100644
index ba52cadf7..000000000
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/MIGRATION.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-# Migration from v1.40.0 to v1.41.0
-
-The `go.opentelemetry.io/otel/semconv/v1.41.0` package should be a drop-in replacement for `go.opentelemetry.io/otel/semconv/v1.40.0` with the following exceptions.
-
-## Removed
-
-The following declarations have been removed.
-Refer to the [OpenTelemetry Semantic Conventions documentation] for deprecation instructions.
-
-If the type is not listed in the documentation as deprecated, it has been removed in this version due to lack of applicability or use.
-If you use any of these non-deprecated declarations in your Go application, please [open an issue] describing your use-case.
-
-- `DeploymentEnvironmentName`
-
-[OpenTelemetry Semantic Conventions documentation]: https://github.com/open-telemetry/semantic-conventions
-[open an issue]: https://github.com/open-telemetry/opentelemetry-go/issues/new?template=Blank+issue
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/README.md b/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/README.md
deleted file mode 100644
index 8353bb715..000000000
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Semconv v1.41.0
-
-[](https://pkg.go.dev/go.opentelemetry.io/otel/semconv/v1.41.0)
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/MIGRATION.md b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/MIGRATION.md
new file mode 100644
index 000000000..54d8e7d70
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/MIGRATION.md
@@ -0,0 +1,4 @@
+
+# Migration from v1.42.0 to v1.43.0
+
+The `go.opentelemetry.io/otel/semconv/v1.43.0` package should be a drop-in replacement for `go.opentelemetry.io/otel/semconv/v1.42.0`.
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/README.md b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/README.md
new file mode 100644
index 000000000..20e64d795
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/README.md
@@ -0,0 +1,3 @@
+# Semconv v1.43.0
+
+[](https://pkg.go.dev/go.opentelemetry.io/otel/semconv/v1.43.0)
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/attribute_group.go b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/attribute_group.go
similarity index 90%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.41.0/attribute_group.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.43.0/attribute_group.go
index 7cee08680..770388dfc 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/attribute_group.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/attribute_group.go
@@ -3,7 +3,7 @@
// Code generated from semantic convention specification. DO NOT EDIT.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.41.0"
+package semconv
import "go.opentelemetry.io/otel/attribute"
@@ -22,7 +22,7 @@ const (
// [Activity lifecycle callbacks], and from which the `OS identifiers` are
// derived.
//
- // [Activity lifecycle callbacks]: https://developer.android.com/guide/components/activities/activity-lifecycle#lc
+ // [Activity lifecycle callbacks]: https://developer.android.com/guide/components/activities/activity-lifecycle#lifecycle-callbacks
AndroidAppStateKey = attribute.Key("android.app.state")
// AndroidOSAPILevelKey is the attribute Key conforming to the
@@ -87,6 +87,24 @@ const (
// "9f2b833506aa6973a92fde9733e6271f", "my-app-1.0.0-code-123"
AppBuildIDKey = attribute.Key("app.build_id")
+ // AppCrashIDKey is the attribute Key conforming to the "app.crash.id" semantic
+ // conventions. It represents a unique identifier representing an instance of an
+ // end-user facing app crash.
+ //
+ // Type: string
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "083d3d2d-9a0e-47f8-be3d-bc3c5538ba38"
+ // Note: Its value MAY be meaningful and be used as a reference for telemetry
+ // and metadata recorded by
+ // the same instrumentation (e.g. it is an ID generated by an external source
+ // that captured the crash).
+ // It MAY come from a source external to the instrumentation such that it can be
+ // used to look up additional
+ // data from other sources as well as facilitate deduplication.
+ AppCrashIDKey = attribute.Key("app.crash.id")
+
// AppInstallationIDKey is the attribute Key conforming to the
// "app.installation.id" semantic conventions. It represents a unique identifier
// representing the installation of an application on a specific device.
@@ -252,6 +270,13 @@ func AppBuildID(val string) attribute.KeyValue {
return AppBuildIDKey.String(val)
}
+// AppCrashID returns an attribute KeyValue conforming to the "app.crash.id"
+// semantic conventions. It represents a unique identifier representing an
+// instance of an end-user facing app crash.
+func AppCrashID(val string) attribute.KeyValue {
+ return AppCrashIDKey.String(val)
+}
+
// AppInstallationID returns an attribute KeyValue conforming to the
// "app.installation.id" semantic conventions. It represents a unique identifier
// representing the installation of an application on a specific device.
@@ -1744,6 +1769,19 @@ const (
// Examples: 1000, 1002
AzureCosmosDBResponseSubStatusCodeKey = attribute.Key("azure.cosmosdb.response.sub_status_code")
+ // AzureResourceGroupNameKey is the attribute Key conforming to the
+ // "azure.resource_group.name" semantic conventions. It represents the name of
+ // the Azure [resource group] the resource belongs to.
+ //
+ // Type: string
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "my-resource-group", "rg-myapp-prod"
+ //
+ // [resource group]: https://learn.microsoft.com/azure/azure-resource-manager/management/manage-resource-groups-portal
+ AzureResourceGroupNameKey = attribute.Key("azure.resource_group.name")
+
// AzureResourceProviderNamespaceKey is the attribute Key conforming to the
// "azure.resource_provider.namespace" semantic conventions. It represents the
// [Azure Resource Provider Namespace] as recognized by the client.
@@ -1808,6 +1846,15 @@ func AzureCosmosDBResponseSubStatusCode(val int) attribute.KeyValue {
return AzureCosmosDBResponseSubStatusCodeKey.Int(val)
}
+// AzureResourceGroupName returns an attribute KeyValue conforming to the
+// "azure.resource_group.name" semantic conventions. It represents the name of
+// the Azure [resource group] the resource belongs to.
+//
+// [resource group]: https://learn.microsoft.com/azure/azure-resource-manager/management/manage-resource-groups-portal
+func AzureResourceGroupName(val string) attribute.KeyValue {
+ return AzureResourceGroupNameKey.String(val)
+}
+
// AzureResourceProviderNamespace returns an attribute KeyValue conforming to the
// "azure.resource_provider.namespace" semantic conventions. It represents the
// [Azure Resource Provider Namespace] as recognized by the client.
@@ -1871,6 +1918,19 @@ const (
// [UA client hints API]: https://wicg.github.io/ua-client-hints/#interface
BrowserBrandsKey = attribute.Key("browser.brands")
+ // BrowserDocumentURLFullKey is the attribute Key conforming to the
+ // "browser.document.url.full" semantic conventions. It represents the absolute
+ // URL of the current browser document according to [RFC3986].
+ //
+ // Type: string
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "https://www.example.com/search?q=OpenTelemetry#SemConv"
+ //
+ // [RFC3986]: https://www.rfc-editor.org/rfc/rfc3986
+ BrowserDocumentURLFullKey = attribute.Key("browser.document.url.full")
+
// BrowserLanguageKey is the attribute Key conforming to the "browser.language"
// semantic conventions. It represents the preferred language of the user using
// the browser.
@@ -1933,6 +1993,15 @@ func BrowserBrands(val ...string) attribute.KeyValue {
return BrowserBrandsKey.StringSlice(val)
}
+// BrowserDocumentURLFull returns an attribute KeyValue conforming to the
+// "browser.document.url.full" semantic conventions. It represents the absolute
+// URL of the current browser document according to [RFC3986].
+//
+// [RFC3986]: https://www.rfc-editor.org/rfc/rfc3986
+func BrowserDocumentURLFull(val string) attribute.KeyValue {
+ return BrowserDocumentURLFullKey.String(val)
+}
+
// BrowserLanguage returns an attribute KeyValue conforming to the
// "browser.language" semantic conventions. It represents the preferred language
// of the user using the browser.
@@ -2107,7 +2176,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "BUILD", "RUN", "SYNC"
CICDPipelineActionNameKey = attribute.Key("cicd.pipeline.action.name")
@@ -2118,7 +2187,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "Build and Test", "Lint", "Deploy Go Project",
// "deploy_to_environment"
@@ -2130,9 +2199,9 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
- // Examples: "success", "failure", "timeout", "skipped"
+ // Examples: "success", "failure", "timeout", "skip"
CICDPipelineResultKey = attribute.Key("cicd.pipeline.result")
// CICDPipelineRunIDKey is the attribute Key conforming to the
@@ -2141,7 +2210,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "120912"
CICDPipelineRunIDKey = attribute.Key("cicd.pipeline.run.id")
@@ -2152,7 +2221,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "pending", "executing", "finalizing"
CICDPipelineRunStateKey = attribute.Key("cicd.pipeline.run.state")
@@ -2164,7 +2233,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples:
// "https://github.com/open-telemetry/semantic-conventions/actions/runs/9753949763?pr=1075"
@@ -2180,7 +2249,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "Run GoLang Linter", "Go Build", "go-test", "deploy_binary"
//
@@ -2193,7 +2262,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "12097"
// Note: For a given pipeline run and task, the `cicd.pipeline.task.run.id` MUST
@@ -2209,9 +2278,9 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
- // Examples: "success", "failure", "timeout", "skipped"
+ // Examples: "success", "failure", "timeout", "skip"
CICDPipelineTaskRunResultKey = attribute.Key("cicd.pipeline.task.run.result")
// CICDPipelineTaskRunURLFullKey is the attribute Key conforming to the
@@ -2221,7 +2290,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples:
// "https://github.com/open-telemetry/semantic-conventions/actions/runs/9753949763/job/26920038674?pr=1075"
@@ -2235,52 +2304,52 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "build", "test", "deploy"
CICDPipelineTaskTypeKey = attribute.Key("cicd.pipeline.task.type")
// CICDSystemComponentKey is the attribute Key conforming to the
// "cicd.system.component" semantic conventions. It represents the name of a
- // component of the CICD system.
+ // component of the CI/CD system.
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "controller", "scheduler", "agent"
CICDSystemComponentKey = attribute.Key("cicd.system.component")
// CICDWorkerIDKey is the attribute Key conforming to the "cicd.worker.id"
// semantic conventions. It represents the unique identifier of a worker within
- // a CICD system.
+ // a CI/CD system.
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "abc123", "10.0.1.2", "controller"
CICDWorkerIDKey = attribute.Key("cicd.worker.id")
// CICDWorkerNameKey is the attribute Key conforming to the "cicd.worker.name"
- // semantic conventions. It represents the name of a worker within a CICD
+ // semantic conventions. It represents the name of a worker within a CI/CD
// system.
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "agent-abc", "controller", "Ubuntu LTS"
CICDWorkerNameKey = attribute.Key("cicd.worker.name")
// CICDWorkerStateKey is the attribute Key conforming to the "cicd.worker.state"
- // semantic conventions. It represents the state of a CICD worker / agent.
+ // semantic conventions. It represents the state of a CI/CD worker / agent.
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
- // Examples: "idle", "busy", "down"
+ // Examples: "available", "busy", "offline"
CICDWorkerStateKey = attribute.Key("cicd.worker.state")
// CICDWorkerURLFullKey is the attribute Key conforming to the
@@ -2290,7 +2359,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "https://cicd.example.org/worker/abc123"
//
@@ -2352,21 +2421,21 @@ func CICDPipelineTaskRunURLFull(val string) attribute.KeyValue {
// CICDSystemComponent returns an attribute KeyValue conforming to the
// "cicd.system.component" semantic conventions. It represents the name of a
-// component of the CICD system.
+// component of the CI/CD system.
func CICDSystemComponent(val string) attribute.KeyValue {
return CICDSystemComponentKey.String(val)
}
// CICDWorkerID returns an attribute KeyValue conforming to the "cicd.worker.id"
// semantic conventions. It represents the unique identifier of a worker within a
-// CICD system.
+// CI/CD system.
func CICDWorkerID(val string) attribute.KeyValue {
return CICDWorkerIDKey.String(val)
}
// CICDWorkerName returns an attribute KeyValue conforming to the
// "cicd.worker.name" semantic conventions. It represents the name of a worker
-// within a CICD system.
+// within a CI/CD system.
func CICDWorkerName(val string) attribute.KeyValue {
return CICDWorkerNameKey.String(val)
}
@@ -2384,39 +2453,39 @@ func CICDWorkerURLFull(val string) attribute.KeyValue {
// Enum values for cicd.pipeline.action.name
var (
// The pipeline run is executing a build.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineActionNameBuild = CICDPipelineActionNameKey.String("BUILD")
// The pipeline run is executing.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineActionNameRun = CICDPipelineActionNameKey.String("RUN")
// The pipeline run is executing a sync.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineActionNameSync = CICDPipelineActionNameKey.String("SYNC")
)
// Enum values for cicd.pipeline.result
var (
// The pipeline run finished successfully.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineResultSuccess = CICDPipelineResultKey.String("success")
// The pipeline run did not finish successfully, eg. due to a compile error or a
// failing test. Such failures are usually detected by non-zero exit codes of
// the tools executed in the pipeline run.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineResultFailure = CICDPipelineResultKey.String("failure")
- // The pipeline run failed due to an error in the CICD system, eg. due to the
+ // The pipeline run failed due to an error in the CI/CD system, eg. due to the
// worker being killed.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineResultError = CICDPipelineResultKey.String("error")
// A timeout caused the pipeline run to be interrupted.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineResultTimeout = CICDPipelineResultKey.String("timeout")
// The pipeline run was cancelled, eg. by a user manually cancelling the
// pipeline run.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineResultCancellation = CICDPipelineResultKey.String("cancellation")
// The pipeline run was skipped, eg. due to a precondition not being met.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineResultSkip = CICDPipelineResultKey.String("skip")
)
@@ -2426,66 +2495,66 @@ var (
// the execution of the run starts (eg. time spent in a queue, provisioning
// agents, creating run resources).
//
- // Stability: development
+ // Stability: release_candidate
CICDPipelineRunStatePending = CICDPipelineRunStateKey.String("pending")
// The executing state spans the execution of any run tasks (eg. build, test).
- // Stability: development
+ // Stability: release_candidate
CICDPipelineRunStateExecuting = CICDPipelineRunStateKey.String("executing")
// The finalizing state spans from when the run has finished executing (eg.
// cleanup of run resources).
- // Stability: development
+ // Stability: release_candidate
CICDPipelineRunStateFinalizing = CICDPipelineRunStateKey.String("finalizing")
)
// Enum values for cicd.pipeline.task.run.result
var (
// The task run finished successfully.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskRunResultSuccess = CICDPipelineTaskRunResultKey.String("success")
// The task run did not finish successfully, eg. due to a compile error or a
// failing test. Such failures are usually detected by non-zero exit codes of
// the tools executed in the task run.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskRunResultFailure = CICDPipelineTaskRunResultKey.String("failure")
- // The task run failed due to an error in the CICD system, eg. due to the worker
- // being killed.
- // Stability: development
+ // The task run failed due to an error in the CI/CD system, eg. due to the
+ // worker being killed.
+ // Stability: release_candidate
CICDPipelineTaskRunResultError = CICDPipelineTaskRunResultKey.String("error")
// A timeout caused the task run to be interrupted.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskRunResultTimeout = CICDPipelineTaskRunResultKey.String("timeout")
// The task run was cancelled, eg. by a user manually cancelling the task run.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskRunResultCancellation = CICDPipelineTaskRunResultKey.String("cancellation")
// The task run was skipped, eg. due to a precondition not being met.
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskRunResultSkip = CICDPipelineTaskRunResultKey.String("skip")
)
// Enum values for cicd.pipeline.task.type
var (
// build
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskTypeBuild = CICDPipelineTaskTypeKey.String("build")
// test
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskTypeTest = CICDPipelineTaskTypeKey.String("test")
// deploy
- // Stability: development
+ // Stability: release_candidate
CICDPipelineTaskTypeDeploy = CICDPipelineTaskTypeKey.String("deploy")
)
// Enum values for cicd.worker.state
var (
- // The worker is not performing work for the CICD system. It is available to the
- // CICD system to perform work on (online / idle).
- // Stability: development
+ // The worker is not performing work for the CI/CD system. It is available to
+ // the CI/CD system to perform work on (online / idle).
+ // Stability: release_candidate
CICDWorkerStateAvailable = CICDWorkerStateKey.String("available")
- // The worker is performing work for the CICD system.
- // Stability: development
+ // The worker is performing work for the CI/CD system.
+ // Stability: release_candidate
CICDWorkerStateBusy = CICDWorkerStateKey.String("busy")
- // The worker is not available to the CICD system (disconnected / down).
- // Stability: development
+ // The worker is not available to the CI/CD system (disconnected / down).
+ // Stability: release_candidate
CICDWorkerStateOffline = CICDWorkerStateKey.String("offline")
)
@@ -2544,7 +2613,9 @@ const (
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "111111111111", "opentelemetry"
+ // Examples: "111111111111", "opentelemetry",
+ // "22222222-2222-2222-2222-222222222222"
+ // Note: For Azure, this is the subscription ID.
CloudAccountIDKey = attribute.Key("cloud.account.id")
// CloudAvailabilityZoneKey is the attribute Key conforming to the
@@ -3436,7 +3507,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "a3bf90e006b2"
//
@@ -3472,7 +3543,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "gcr.io/opentelemetry/operator"
ContainerImageNameKey = attribute.Key("container.image.name")
@@ -3483,7 +3554,7 @@ const (
//
// Type: string[]
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples:
// "example@sha256:afcc7f1ac1b49db317a7196c902e61c6c3c4607d63599ee1a82d702d249a0ccb",
@@ -3502,7 +3573,7 @@ const (
//
// Type: string[]
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "v1.27.1", "3.5.7-0"
//
@@ -3691,7 +3762,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "user", "system"
CPUModeKey = attribute.Key("cpu.mode")
@@ -3707,29 +3778,26 @@ func CPULogicalNumber(val int) attribute.KeyValue {
// Enum values for cpu.mode
var (
// User
- // Stability: development
+ // Stability: release_candidate
CPUModeUser = CPUModeKey.String("user")
// System
- // Stability: development
+ // Stability: release_candidate
CPUModeSystem = CPUModeKey.String("system")
// Nice
- // Stability: development
+ // Stability: release_candidate
CPUModeNice = CPUModeKey.String("nice")
// Idle
- // Stability: development
+ // Stability: release_candidate
CPUModeIdle = CPUModeKey.String("idle")
// IO Wait
- // Stability: development
+ // Stability: release_candidate
CPUModeIOWait = CPUModeKey.String("iowait")
// Interrupt
- // Stability: development
+ // Stability: release_candidate
CPUModeInterrupt = CPUModeKey.String("interrupt")
// Steal
- // Stability: development
+ // Stability: release_candidate
CPUModeSteal = CPUModeKey.String("steal")
- // Kernel
- // Stability: development
- CPUModeKernel = CPUModeKey.String("kernel")
)
// Namespace: db
@@ -3803,15 +3871,46 @@ const (
// DBOperationBatchSizeKey is the attribute Key conforming to the
// "db.operation.batch.size" semantic conventions. It represents the number of
- // queries included in a batch operation.
+ // database operations included in a batch operation.
//
// Type: int
// RequirementLevel: Recommended
// Stability: Stable
//
// Examples: 2, 3, 4
- // Note: Operations are only considered batches when they contain two or more
- // operations, and so `db.operation.batch.size` SHOULD never be `1`.
+ // Note: Except for empty batch requests described below, a batch operation
+ // contains two
+ // or more database operations explicitly submitted as separate operations in a
+ // single
+ // client call, protocol message, or database command.
+ //
+ // Requests to batch APIs that contain only one operation SHOULD be modeled as
+ // single
+ // operations, not as batch operations.
+ //
+ // A database call is not a batch operation solely because one operation accepts
+ // multiple operands, such as keys, rows, documents, points, or other data
+ // elements,
+ // including Redis [`MGET`] with
+ // multiple keys.
+ //
+ // In batch APIs that execute the same parameterized operation with parameter
+ // sets,
+ // each parameter set represents one database operation for determining whether
+ // the
+ // request is a batch operation. Requests with only one parameter set SHOULD be
+ // modeled
+ // as single operations, not as batch operations.
+ //
+ // `db.operation.batch.size` SHOULD be set to the number of operations in the
+ // batch.
+ // It SHOULD NOT be set for non-batch operations.
+ //
+ // A request to execute a batch operation with no operations SHOULD also be
+ // treated
+ // as a batch operation, and `db.operation.batch.size` SHOULD be set to `0`.
+ //
+ // [`MGET`]: https://redis.io/docs/latest/commands/mget/
DBOperationBatchSizeKey = attribute.Key("db.operation.batch.size")
// DBOperationNameKey is the attribute Key conforming to the "db.operation.name"
@@ -3980,7 +4079,7 @@ func DBNamespace(val string) attribute.KeyValue {
// DBOperationBatchSize returns an attribute KeyValue conforming to the
// "db.operation.batch.size" semantic conventions. It represents the number of
-// queries included in a batch operation.
+// database operations included in a batch operation.
func DBOperationBatchSize(val int) attribute.KeyValue {
return DBOperationBatchSizeKey.Int(val)
}
@@ -4511,7 +4610,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "read"
DiskIODirectionKey = attribute.Key("disk.io.direction")
@@ -4520,10 +4619,10 @@ const (
// Enum values for disk.io.direction
var (
// read
- // Stability: development
+ // Stability: release_candidate
DiskIODirectionRead = DiskIODirectionKey.String("read")
// write
- // Stability: development
+ // Stability: release_candidate
DiskIODirectionWrite = DiskIODirectionKey.String("write")
)
@@ -5496,6 +5595,45 @@ const (
// Examples: "256383"
FileInodeKey = attribute.Key("file.inode")
+ // FileLockMechanismKey is the attribute Key conforming to the
+ // "file.lock.mechanism" semantic conventions. It represents the lock mechanism
+ // such as noted by [POSIX].
+ //
+ // Type: string
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "POSIX", "FLOCK", "DELEG", "LEASE"
+ //
+ // [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html
+ FileLockMechanismKey = attribute.Key("file.lock.mechanism")
+
+ // FileLockModeKey is the attribute Key conforming to the "file.lock.mode"
+ // semantic conventions. It represents the mode of lock or operation such as
+ // documented by [POSIX].
+ //
+ // Type: string
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "ADVISORY", "MANDATORY", "BREAKING", "ACTIVE", "BREAKER"
+ //
+ // [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html
+ FileLockModeKey = attribute.Key("file.lock.mode")
+
+ // FileLockTypeKey is the attribute Key conforming to the "file.lock.type"
+ // semantic conventions. It represents the lock type as represented by i.e.
+ // [POSIX]'s l_type.
+ //
+ // Type: Enum
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "read"
+ //
+ // [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html
+ FileLockTypeKey = attribute.Key("file.lock.type")
+
// FileModeKey is the attribute Key conforming to the "file.mode" semantic
// conventions. It represents the mode of the file in octal representation.
//
@@ -5652,6 +5790,24 @@ func FileInode(val string) attribute.KeyValue {
return FileInodeKey.String(val)
}
+// FileLockMechanism returns an attribute KeyValue conforming to the
+// "file.lock.mechanism" semantic conventions. It represents the lock mechanism
+// such as noted by [POSIX].
+//
+// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html
+func FileLockMechanism(val string) attribute.KeyValue {
+ return FileLockMechanismKey.String(val)
+}
+
+// FileLockMode returns an attribute KeyValue conforming to the "file.lock.mode"
+// semantic conventions. It represents the mode of lock or operation such as
+// documented by [POSIX].
+//
+// [POSIX]: https://pubs.opengroup.org/onlinepubs/9699919799/functions/fcntl.html
+func FileLockMode(val string) attribute.KeyValue {
+ return FileLockModeKey.String(val)
+}
+
// FileMode returns an attribute KeyValue conforming to the "file.mode" semantic
// conventions. It represents the mode of the file in octal representation.
func FileMode(val string) attribute.KeyValue {
@@ -5706,6 +5862,16 @@ func FileSymbolicLinkTargetPath(val string) attribute.KeyValue {
return FileSymbolicLinkTargetPathKey.String(val)
}
+// Enum values for file.lock.type
+var (
+ // read
+ // Stability: development
+ FileLockTypeRead = FileLockTypeKey.String("read")
+ // write
+ // Stability: development
+ FileLockTypeWrite = FileLockTypeKey.String("write")
+)
+
// Namespace: gcp
const (
// GCPAppHubApplicationContainerKey is the attribute Key conforming to the
@@ -6152,6 +6318,13 @@ func GCPGCEInstanceHostname(val string) attribute.KeyValue {
return GCPGCEInstanceHostnameKey.String(val)
}
+// GCPGCEInstanceLabels returns an attribute KeyValue conforming to the
+// "gcp.gce.instance.labels" semantic conventions. It represents the GCE instance
+// labels, `` being the label name and the value being the label value.
+func GCPGCEInstanceLabels(key string, val string) attribute.KeyValue {
+ return attribute.String("gcp.gce.instance.labels."+key, val)
+}
+
// GCPGCEInstanceName returns an attribute KeyValue conforming to the
// "gcp.gce.instance.name" semantic conventions. It represents the instance name
// of a GCE instance. This is the value provided by `host.name`, the visible name
@@ -6314,1270 +6487,94 @@ var (
GCPAppHubDestinationWorkloadEnvironmentTypeDevelopment = GCPAppHubDestinationWorkloadEnvironmentTypeKey.String("DEVELOPMENT")
)
-// Namespace: gen_ai
+// Namespace: geo
const (
- // GenAIAgentDescriptionKey is the attribute Key conforming to the
- // "gen_ai.agent.description" semantic conventions. It represents the free-form
- // description of the GenAI agent provided by the application.
+ // GeoContinentCodeKey is the attribute Key conforming to the
+ // "geo.continent.code" semantic conventions. It represents the two-letter code
+ // representing continent’s name.
//
- // Type: string
+ // Type: Enum
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "Helps with math problems", "Generates fiction stories"
- GenAIAgentDescriptionKey = attribute.Key("gen_ai.agent.description")
+ // Examples:
+ GeoContinentCodeKey = attribute.Key("geo.continent.code")
- // GenAIAgentIDKey is the attribute Key conforming to the "gen_ai.agent.id"
- // semantic conventions. It represents the unique identifier of the GenAI agent.
+ // GeoCountryISOCodeKey is the attribute Key conforming to the
+ // "geo.country.iso_code" semantic conventions. It represents the two-letter ISO
+ // Country Code ([ISO 3166-1 alpha2]).
//
// Type: string
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "asst_5j66UpCpwteGg4YSxUnt7lPY"
- GenAIAgentIDKey = attribute.Key("gen_ai.agent.id")
-
- // GenAIAgentNameKey is the attribute Key conforming to the "gen_ai.agent.name"
- // semantic conventions. It represents the human-readable name of the GenAI
- // agent provided by the application.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
+ // Examples: "CA"
//
- // Examples: "Math Tutor", "Fiction Writer"
- GenAIAgentNameKey = attribute.Key("gen_ai.agent.name")
+ // [ISO 3166-1 alpha2]: https://wikipedia.org/wiki/ISO_3166-1#Codes
+ GeoCountryISOCodeKey = attribute.Key("geo.country.iso_code")
- // GenAIAgentVersionKey is the attribute Key conforming to the
- // "gen_ai.agent.version" semantic conventions. It represents the version of the
- // GenAI agent.
+ // GeoLocalityNameKey is the attribute Key conforming to the "geo.locality.name"
+ // semantic conventions. It represents the locality name. Represents the name of
+ // a city, town, village, or similar populated place.
//
// Type: string
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "1.0.0", "2025-05-01"
- GenAIAgentVersionKey = attribute.Key("gen_ai.agent.version")
+ // Examples: "Montreal", "Berlin"
+ GeoLocalityNameKey = attribute.Key("geo.locality.name")
- // GenAIConversationIDKey is the attribute Key conforming to the
- // "gen_ai.conversation.id" semantic conventions. It represents the unique
- // identifier for a conversation (session, thread), used to store and correlate
- // messages within this conversation.
+ // GeoLocationLatKey is the attribute Key conforming to the "geo.location.lat"
+ // semantic conventions. It represents the latitude of the geo location in
+ // [WGS84].
//
- // Type: string
+ // Type: double
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "conv_5j66UpCpwteGg4YSxUnt7lPY"
- GenAIConversationIDKey = attribute.Key("gen_ai.conversation.id")
-
- // GenAIDataSourceIDKey is the attribute Key conforming to the
- // "gen_ai.data_source.id" semantic conventions. It represents the data source
- // identifier.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
+ // Examples: 45.505918
//
- // Examples: "H7STPQYOND"
- // Note: Data sources are used by AI agents and RAG applications to store
- // grounding data. A data source may be an external database, object store,
- // document collection, website, or any other storage system used by the GenAI
- // agent or application. The `gen_ai.data_source.id` SHOULD match the identifier
- // used by the GenAI system rather than a name specific to the external storage,
- // such as a database or object store. Semantic conventions referencing
- // `gen_ai.data_source.id` MAY also leverage additional attributes, such as
- // `db.*`, to further identify and describe the data source.
- GenAIDataSourceIDKey = attribute.Key("gen_ai.data_source.id")
+ // [WGS84]: https://wikipedia.org/wiki/World_Geodetic_System#WGS84
+ GeoLocationLatKey = attribute.Key("geo.location.lat")
- // GenAIEmbeddingsDimensionCountKey is the attribute Key conforming to the
- // "gen_ai.embeddings.dimension.count" semantic conventions. It represents the
- // number of dimensions the resulting output embeddings should have.
+ // GeoLocationLonKey is the attribute Key conforming to the "geo.location.lon"
+ // semantic conventions. It represents the longitude of the geo location in
+ // [WGS84].
//
- // Type: int
+ // Type: double
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: 512, 1024
- GenAIEmbeddingsDimensionCountKey = attribute.Key("gen_ai.embeddings.dimension.count")
-
- // GenAIEvaluationExplanationKey is the attribute Key conforming to the
- // "gen_ai.evaluation.explanation" semantic conventions. It represents a
- // free-form explanation for the assigned score provided by the evaluator.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
+ // Examples: -73.61483
//
- // Examples: "The response is factually accurate but lacks sufficient detail to
- // fully address the question."
- GenAIEvaluationExplanationKey = attribute.Key("gen_ai.evaluation.explanation")
+ // [WGS84]: https://wikipedia.org/wiki/World_Geodetic_System#WGS84
+ GeoLocationLonKey = attribute.Key("geo.location.lon")
- // GenAIEvaluationNameKey is the attribute Key conforming to the
- // "gen_ai.evaluation.name" semantic conventions. It represents the name of the
- // evaluation metric used for the GenAI response.
+ // GeoPostalCodeKey is the attribute Key conforming to the "geo.postal_code"
+ // semantic conventions. It represents the postal code associated with the
+ // location. Values appropriate for this field may also be known as a postcode
+ // or ZIP code and will vary widely from country to country.
//
// Type: string
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "Relevance", "IntentResolution"
- GenAIEvaluationNameKey = attribute.Key("gen_ai.evaluation.name")
+ // Examples: "94040"
+ GeoPostalCodeKey = attribute.Key("geo.postal_code")
- // GenAIEvaluationScoreLabelKey is the attribute Key conforming to the
- // "gen_ai.evaluation.score.label" semantic conventions. It represents the human
- // readable label for evaluation.
+ // GeoRegionISOCodeKey is the attribute Key conforming to the
+ // "geo.region.iso_code" semantic conventions. It represents the region ISO code
+ // ([ISO 3166-2]).
//
// Type: string
// RequirementLevel: Recommended
// Stability: Development
//
- // Examples: "relevant", "not_relevant", "correct", "incorrect", "pass", "fail"
- // Note: This attribute provides a human-readable interpretation of the
- // evaluation score produced by an evaluator. For example, a score value of 1
- // could mean "relevant" in one evaluation system and "not relevant" in another,
- // depending on the scoring range and evaluator. The label SHOULD have low
- // cardinality. Possible values depend on the evaluation metric and evaluator
- // used; implementations SHOULD document the possible values.
- GenAIEvaluationScoreLabelKey = attribute.Key("gen_ai.evaluation.score.label")
-
- // GenAIEvaluationScoreValueKey is the attribute Key conforming to the
- // "gen_ai.evaluation.score.value" semantic conventions. It represents the
- // evaluation score returned by the evaluator.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
+ // Examples: "CA-QC"
//
- // Examples: 4.0
- GenAIEvaluationScoreValueKey = attribute.Key("gen_ai.evaluation.score.value")
-
- // GenAIInputMessagesKey is the attribute Key conforming to the
- // "gen_ai.input.messages" semantic conventions. It represents the chat history
- // provided to the model as an input.
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "[\n {\n "role": "user",\n "parts": [\n {\n "type": "text",\n
- // "content": "Weather in Paris?"\n }\n ]\n },\n {\n "role": "assistant",\n
- // "parts": [\n {\n "type": "tool_call",\n "id":
- // "call_VSPygqKTWdrhaFErNvMV18Yl",\n "name": "get_weather",\n "arguments": {\n
- // "location": "Paris"\n }\n }\n ]\n },\n {\n "role": "tool",\n "parts": [\n {\n
- // "type": "tool_call_response",\n "id": " call_VSPygqKTWdrhaFErNvMV18Yl",\n
- // "result": "rainy, 57°F"\n }\n ]\n }\n]\n"
- // Note: Instrumentations MUST follow [Input messages JSON schema].
- // When the attribute is recorded on events, it MUST be recorded in structured
- // form. When recorded on spans, it MAY be recorded as a JSON string if
- // structured
- // format is not supported and SHOULD be recorded in structured form otherwise.
- //
- // Messages MUST be provided in the order they were sent to the model.
- // Instrumentations MAY provide a way for users to filter or truncate
- // input messages.
- //
- // > [!Warning]
- // > This attribute is likely to contain sensitive information including
- // > user/PII data.
- //
- // See [Recording content on attributes]
- // section for more details.
- //
- // [Input messages JSON schema]: /docs/gen-ai/gen-ai-input-messages.json
- // [Recording content on attributes]: /docs/gen-ai/gen-ai-spans.md#recording-content-on-attributes
- GenAIInputMessagesKey = attribute.Key("gen_ai.input.messages")
-
- // GenAIOperationNameKey is the attribute Key conforming to the
- // "gen_ai.operation.name" semantic conventions. It represents the name of the
- // operation being performed.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- // Note: If one of the predefined values applies, but specific system uses a
- // different name it's RECOMMENDED to document it in the semantic conventions
- // for specific GenAI system and use system-specific name in the
- // instrumentation. If a different name is not documented, instrumentation
- // libraries SHOULD use applicable predefined value.
- GenAIOperationNameKey = attribute.Key("gen_ai.operation.name")
-
- // GenAIOutputMessagesKey is the attribute Key conforming to the
- // "gen_ai.output.messages" semantic conventions. It represents the messages
- // returned by the model where each message represents a specific model response
- // (choice, candidate).
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "[\n {\n "role": "assistant",\n "parts": [\n {\n "type": "text",\n
- // "content": "The weather in Paris is currently rainy with a temperature of
- // 57°F."\n }\n ],\n "finish_reason": "stop"\n }\n]\n"
- // Note: Instrumentations MUST follow [Output messages JSON schema]
- //
- // Each message represents a single output choice/candidate generated by
- // the model. Each message corresponds to exactly one generation
- // (choice/candidate) and vice versa - one choice cannot be split across
- // multiple messages or one message cannot contain parts from multiple choices.
- //
- // When the attribute is recorded on events, it MUST be recorded in structured
- // form. When recorded on spans, it MAY be recorded as a JSON string if
- // structured
- // format is not supported and SHOULD be recorded in structured form otherwise.
- //
- // Instrumentations MAY provide a way for users to filter or truncate
- // output messages.
- //
- // > [!Warning]
- // > This attribute is likely to contain sensitive information including
- // > user/PII data.
- //
- // See [Recording content on attributes]
- // section for more details.
- //
- // [Output messages JSON schema]: /docs/gen-ai/gen-ai-output-messages.json
- // [Recording content on attributes]: /docs/gen-ai/gen-ai-spans.md#recording-content-on-attributes
- GenAIOutputMessagesKey = attribute.Key("gen_ai.output.messages")
-
- // GenAIOutputTypeKey is the attribute Key conforming to the
- // "gen_ai.output.type" semantic conventions. It represents the represents the
- // content type requested by the client.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- // Note: This attribute SHOULD be used when the client requests output of a
- // specific type. The model may return zero or more outputs of this type.
- // This attribute specifies the output modality and not the actual output
- // format. For example, if an image is requested, the actual output could be a
- // URL pointing to an image file.
- // Additional output format details may be recorded in the future in the
- // `gen_ai.output.{type}.*` attributes.
- GenAIOutputTypeKey = attribute.Key("gen_ai.output.type")
-
- // GenAIPromptNameKey is the attribute Key conforming to the
- // "gen_ai.prompt.name" semantic conventions. It represents the name of the
- // prompt that uniquely identifies it.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "analyze-code"
- GenAIPromptNameKey = attribute.Key("gen_ai.prompt.name")
-
- // GenAIProviderNameKey is the attribute Key conforming to the
- // "gen_ai.provider.name" semantic conventions. It represents the Generative AI
- // provider as identified by the client or server instrumentation.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- // Note: The attribute SHOULD be set based on the instrumentation's best
- // knowledge and may differ from the actual model provider.
- //
- // Multiple providers, including Azure OpenAI, Gemini, and AI hosting platforms
- // are accessible using the OpenAI REST API and corresponding client libraries,
- // but may proxy or host models from different providers.
- //
- // The `gen_ai.request.model`, `gen_ai.response.model`, and `server.address`
- // attributes may help identify the actual system in use.
- //
- // The `gen_ai.provider.name` attribute acts as a discriminator that
- // identifies the GenAI telemetry format flavor specific to that provider
- // within GenAI semantic conventions.
- // It SHOULD be set consistently with provider-specific attributes and signals.
- // For example, GenAI spans, metrics, and events related to AWS Bedrock
- // should have the `gen_ai.provider.name` set to `aws.bedrock` and include
- // applicable `aws.bedrock.*` attributes and are not expected to include
- // `openai.*` attributes.
- GenAIProviderNameKey = attribute.Key("gen_ai.provider.name")
-
- // GenAIRequestChoiceCountKey is the attribute Key conforming to the
- // "gen_ai.request.choice.count" semantic conventions. It represents the target
- // number of candidate completions to return.
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 3
- GenAIRequestChoiceCountKey = attribute.Key("gen_ai.request.choice.count")
-
- // GenAIRequestEncodingFormatsKey is the attribute Key conforming to the
- // "gen_ai.request.encoding_formats" semantic conventions. It represents the
- // encoding formats requested in an embeddings operation, if specified.
- //
- // Type: string[]
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "base64"], ["float", "binary"
- // Note: In some GenAI systems the encoding formats are called embedding types.
- // Also, some GenAI systems only accept a single format per request.
- GenAIRequestEncodingFormatsKey = attribute.Key("gen_ai.request.encoding_formats")
-
- // GenAIRequestFrequencyPenaltyKey is the attribute Key conforming to the
- // "gen_ai.request.frequency_penalty" semantic conventions. It represents the
- // frequency penalty setting for the GenAI request.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 0.1
- GenAIRequestFrequencyPenaltyKey = attribute.Key("gen_ai.request.frequency_penalty")
-
- // GenAIRequestMaxTokensKey is the attribute Key conforming to the
- // "gen_ai.request.max_tokens" semantic conventions. It represents the maximum
- // number of tokens the model generates for a request.
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 100
- GenAIRequestMaxTokensKey = attribute.Key("gen_ai.request.max_tokens")
-
- // GenAIRequestModelKey is the attribute Key conforming to the
- // "gen_ai.request.model" semantic conventions. It represents the name of the
- // GenAI model a request is being made to.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: gpt-4
- GenAIRequestModelKey = attribute.Key("gen_ai.request.model")
-
- // GenAIRequestPresencePenaltyKey is the attribute Key conforming to the
- // "gen_ai.request.presence_penalty" semantic conventions. It represents the
- // presence penalty setting for the GenAI request.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 0.1
- GenAIRequestPresencePenaltyKey = attribute.Key("gen_ai.request.presence_penalty")
-
- // GenAIRequestSeedKey is the attribute Key conforming to the
- // "gen_ai.request.seed" semantic conventions. It represents the requests with
- // same seed value more likely to return same result.
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 100
- GenAIRequestSeedKey = attribute.Key("gen_ai.request.seed")
-
- // GenAIRequestStopSequencesKey is the attribute Key conforming to the
- // "gen_ai.request.stop_sequences" semantic conventions. It represents the list
- // of sequences that the model will use to stop generating further tokens.
- //
- // Type: string[]
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "forest", "lived"
- GenAIRequestStopSequencesKey = attribute.Key("gen_ai.request.stop_sequences")
-
- // GenAIRequestStreamKey is the attribute Key conforming to the
- // "gen_ai.request.stream" semantic conventions. It represents the indicates
- // whether the GenAI request was made in streaming mode.
- //
- // Type: boolean
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- GenAIRequestStreamKey = attribute.Key("gen_ai.request.stream")
-
- // GenAIRequestTemperatureKey is the attribute Key conforming to the
- // "gen_ai.request.temperature" semantic conventions. It represents the
- // temperature setting for the GenAI request.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 0.0
- GenAIRequestTemperatureKey = attribute.Key("gen_ai.request.temperature")
-
- // GenAIRequestTopKKey is the attribute Key conforming to the
- // "gen_ai.request.top_k" semantic conventions. It represents the top_k sampling
- // setting for the GenAI request.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 1.0
- GenAIRequestTopKKey = attribute.Key("gen_ai.request.top_k")
-
- // GenAIRequestTopPKey is the attribute Key conforming to the
- // "gen_ai.request.top_p" semantic conventions. It represents the top_p sampling
- // setting for the GenAI request.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 1.0
- GenAIRequestTopPKey = attribute.Key("gen_ai.request.top_p")
-
- // GenAIResponseFinishReasonsKey is the attribute Key conforming to the
- // "gen_ai.response.finish_reasons" semantic conventions. It represents the
- // array of reasons the model stopped generating tokens, corresponding to each
- // generation received.
- //
- // Type: string[]
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "stop"], ["stop", "length"
- GenAIResponseFinishReasonsKey = attribute.Key("gen_ai.response.finish_reasons")
-
- // GenAIResponseIDKey is the attribute Key conforming to the
- // "gen_ai.response.id" semantic conventions. It represents the unique
- // identifier for the completion.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "chatcmpl-123"
- GenAIResponseIDKey = attribute.Key("gen_ai.response.id")
-
- // GenAIResponseModelKey is the attribute Key conforming to the
- // "gen_ai.response.model" semantic conventions. It represents the name of the
- // model that generated the response.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "gpt-4-0613"
- GenAIResponseModelKey = attribute.Key("gen_ai.response.model")
-
- // GenAIResponseTimeToFirstChunkKey is the attribute Key conforming to the
- // "gen_ai.response.time_to_first_chunk" semantic conventions. It represents the
- // time to first chunk in a streaming response, measured from request issuance,
- // in seconds. The value is measured from when the client issues the generation
- // request to when the first chunk is received in the response stream.
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 0.5, 1.2
- GenAIResponseTimeToFirstChunkKey = attribute.Key("gen_ai.response.time_to_first_chunk")
-
- // GenAIRetrievalDocumentsKey is the attribute Key conforming to the
- // "gen_ai.retrieval.documents" semantic conventions. It represents the
- // documents retrieved.
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "[\n {\n "id": "doc_123",\n "score": 0.95\n },\n {\n "id":
- // "doc_456",\n "score": 0.87\n },\n {\n "id": "doc_789",\n "score": 0.82\n
- // }\n]\n"
- // Note: Instrumentations MUST follow [Retrieval documents JSON schema].
- // When the attribute is recorded on events, it MUST be recorded in structured
- // form. When recorded on spans, it MAY be recorded as a JSON string if
- // structured
- // format is not supported and SHOULD be recorded in structured form otherwise.
- //
- // Each document object SHOULD contain at least the following properties:
- // `id` (string): A unique identifier for the document, `score` (double): The
- // relevance score of the document
- //
- // [Retrieval documents JSON schema]: /docs/gen-ai/gen-ai-retrieval-documents.json
- GenAIRetrievalDocumentsKey = attribute.Key("gen_ai.retrieval.documents")
-
- // GenAIRetrievalQueryTextKey is the attribute Key conforming to the
- // "gen_ai.retrieval.query.text" semantic conventions. It represents the query
- // text used for retrieval.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "What is the capital of France?", "weather in Paris"
- // Note: > [!Warning]
- //
- // > This attribute may contain sensitive information.
- GenAIRetrievalQueryTextKey = attribute.Key("gen_ai.retrieval.query.text")
-
- // GenAISystemInstructionsKey is the attribute Key conforming to the
- // "gen_ai.system_instructions" semantic conventions. It represents the system
- // message or instructions provided to the GenAI model separately from the chat
- // history.
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "[\n {\n "type": "text",\n "content": "You are an Agent that greet
- // users, always use greetings tool to respond"\n }\n]\n", "[\n {\n "type":
- // "text",\n "content": "You are a language translator."\n },\n {\n "type":
- // "text",\n "content": "Your mission is to translate text in English to
- // French."\n }\n]\n"
- // Note: This attribute SHOULD be used when the corresponding provider or API
- // allows to provide system instructions or messages separately from the
- // chat history.
- //
- // Instructions that are part of the chat history SHOULD be recorded in
- // `gen_ai.input.messages` attribute instead.
- //
- // Instrumentations MUST follow [System instructions JSON schema].
- //
- // When recorded on spans, it MAY be recorded as a JSON string if structured
- // format is not supported and SHOULD be recorded in structured form otherwise.
- //
- // Instrumentations MAY provide a way for users to filter or truncate
- // system instructions.
- //
- // > [!Warning]
- // > This attribute may contain sensitive information.
- //
- // See [Recording content on attributes]
- // section for more details.
- //
- // [System instructions JSON schema]: /docs/gen-ai/gen-ai-system-instructions.json
- // [Recording content on attributes]: /docs/gen-ai/gen-ai-spans.md#recording-content-on-attributes
- GenAISystemInstructionsKey = attribute.Key("gen_ai.system_instructions")
-
- // GenAITokenTypeKey is the attribute Key conforming to the "gen_ai.token.type"
- // semantic conventions. It represents the type of token being counted.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "input", "output"
- GenAITokenTypeKey = attribute.Key("gen_ai.token.type")
-
- // GenAIToolCallArgumentsKey is the attribute Key conforming to the
- // "gen_ai.tool.call.arguments" semantic conventions. It represents the
- // parameters passed to the tool call.
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "{\n "location": "San Francisco?",\n "date": "2025-10-01"\n}\n"
- // Note: > [!WARNING]
- //
- // > This attribute may contain sensitive information.
- //
- // It's expected to be an object - in case a serialized string is available
- // to the instrumentation, the instrumentation SHOULD do the best effort to
- // deserialize it to an object. When recorded on spans, it MAY be recorded as a
- // JSON string if structured format is not supported and SHOULD be recorded in
- // structured form otherwise.
- GenAIToolCallArgumentsKey = attribute.Key("gen_ai.tool.call.arguments")
-
- // GenAIToolCallIDKey is the attribute Key conforming to the
- // "gen_ai.tool.call.id" semantic conventions. It represents the tool call
- // identifier.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "call_mszuSIzqtI65i1wAUOE8w5H4"
- GenAIToolCallIDKey = attribute.Key("gen_ai.tool.call.id")
-
- // GenAIToolCallResultKey is the attribute Key conforming to the
- // "gen_ai.tool.call.result" semantic conventions. It represents the result
- // returned by the tool call (if any and if execution was successful).
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "{\n "temperature_range": {\n "high": 75,\n "low": 60\n },\n
- // "conditions": "sunny"\n}\n"
- // Note: > [!WARNING]
- //
- // > This attribute may contain sensitive information.
- //
- // It's expected to be an object - in case a serialized string is available
- // to the instrumentation, the instrumentation SHOULD do the best effort to
- // deserialize it to an object. When recorded on spans, it MAY be recorded as a
- // JSON string if structured format is not supported and SHOULD be recorded in
- // structured form otherwise.
- GenAIToolCallResultKey = attribute.Key("gen_ai.tool.call.result")
-
- // GenAIToolDefinitionsKey is the attribute Key conforming to the
- // "gen_ai.tool.definitions" semantic conventions. It represents the list of
- // tool definitions available to the GenAI agent or model.
- //
- // Type: any
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "[\n {\n "type": "function",\n "name": "get_current_weather",\n
- // "description": "Get the current weather in a given location",\n "parameters":
- // {\n "type": "object",\n "properties": {\n "location": {\n "type": "string",\n
- // "description": "The city and state, e.g. San Francisco, CA"\n },\n "unit":
- // {\n "type": "string",\n "enum": [\n "celsius",\n "fahrenheit"\n ]\n }\n },\n
- // "required": [\n "location",\n "unit"\n ]\n }\n }\n]\n"
- // Note: Instrumentations MUST follow [Tool Definitions JSON Schema].
- //
- // When the attribute is recorded on events, it MUST be recorded in structured
- // form. When recorded on spans, it MAY be recorded as a JSON string if
- // structured
- // format is not supported and SHOULD be recorded in structured form otherwise.
- //
- // Since this attribute could be large, it's NOT RECOMMENDED to populate
- // non-required properties by default. Instrumentations MAY provide a way
- // to enable populating optional properties.
- //
- // [Tool Definitions JSON Schema]: /docs/gen-ai/gen-ai-tool-definitions.json
- GenAIToolDefinitionsKey = attribute.Key("gen_ai.tool.definitions")
-
- // GenAIToolDescriptionKey is the attribute Key conforming to the
- // "gen_ai.tool.description" semantic conventions. It represents the tool
- // description.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "Multiply two numbers"
- GenAIToolDescriptionKey = attribute.Key("gen_ai.tool.description")
-
- // GenAIToolNameKey is the attribute Key conforming to the "gen_ai.tool.name"
- // semantic conventions. It represents the name of the tool utilized by the
- // agent.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "Flights"
- GenAIToolNameKey = attribute.Key("gen_ai.tool.name")
-
- // GenAIToolTypeKey is the attribute Key conforming to the "gen_ai.tool.type"
- // semantic conventions. It represents the type of the tool utilized by the
- // agent.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "function", "extension", "datastore"
- // Note: Extension: A tool executed on the agent-side to directly call external
- // APIs, bridging the gap between the agent and real-world systems.
- // Agent-side operations involve actions that are performed by the agent on the
- // server or within the agent's controlled environment.
- // Function: A tool executed on the client-side, where the agent generates
- // parameters for a predefined function, and the client executes the logic.
- // Client-side operations are actions taken on the user's end or within the
- // client application.
- // Datastore: A tool used by the agent to access and query structured or
- // unstructured external data for retrieval-augmented tasks or knowledge
- // updates.
- GenAIToolTypeKey = attribute.Key("gen_ai.tool.type")
-
- // GenAIUsageCacheCreationInputTokensKey is the attribute Key conforming to the
- // "gen_ai.usage.cache_creation.input_tokens" semantic conventions. It
- // represents the number of input tokens written to a provider-managed cache.
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 25
- // Note: The value SHOULD be included in `gen_ai.usage.input_tokens`.
- GenAIUsageCacheCreationInputTokensKey = attribute.Key("gen_ai.usage.cache_creation.input_tokens")
-
- // GenAIUsageCacheReadInputTokensKey is the attribute Key conforming to the
- // "gen_ai.usage.cache_read.input_tokens" semantic conventions. It represents
- // the number of input tokens served from a provider-managed cache.
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 50
- // Note: The value SHOULD be included in `gen_ai.usage.input_tokens`.
- GenAIUsageCacheReadInputTokensKey = attribute.Key("gen_ai.usage.cache_read.input_tokens")
-
- // GenAIUsageInputTokensKey is the attribute Key conforming to the
- // "gen_ai.usage.input_tokens" semantic conventions. It represents the number of
- // tokens used in the GenAI input (prompt).
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 100
- // Note: This value SHOULD include all types of input tokens, including cached
- // tokens.
- // Instrumentations SHOULD make a best effort to populate this value, using a
- // total
- // provided by the provider when available or, depending on the provider API,
- // by summing different token types parsed from the provider output.
- GenAIUsageInputTokensKey = attribute.Key("gen_ai.usage.input_tokens")
-
- // GenAIUsageOutputTokensKey is the attribute Key conforming to the
- // "gen_ai.usage.output_tokens" semantic conventions. It represents the number
- // of tokens used in the GenAI response (completion).
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 180
- GenAIUsageOutputTokensKey = attribute.Key("gen_ai.usage.output_tokens")
-
- // GenAIUsageReasoningOutputTokensKey is the attribute Key conforming to the
- // "gen_ai.usage.reasoning.output_tokens" semantic conventions. It represents
- // the number of output tokens used for reasoning (e.g. chain-of-thought,
- // extended thinking).
- //
- // Type: int
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 50
- // Note: The value SHOULD be included in `gen_ai.usage.output_tokens`.
- GenAIUsageReasoningOutputTokensKey = attribute.Key("gen_ai.usage.reasoning.output_tokens")
-
- // GenAIWorkflowNameKey is the attribute Key conforming to the
- // "gen_ai.workflow.name" semantic conventions. It represents the human-readable
- // name of the GenAI workflow provided by the application.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "multi_agent_rag", "customer_support_pipeline"
- // Note: This attribute can be populated in different frameworks eg: name of the
- // first chain in LangChain OR name of the crew in CrewAI.
- GenAIWorkflowNameKey = attribute.Key("gen_ai.workflow.name")
-)
-
-// GenAIAgentDescription returns an attribute KeyValue conforming to the
-// "gen_ai.agent.description" semantic conventions. It represents the free-form
-// description of the GenAI agent provided by the application.
-func GenAIAgentDescription(val string) attribute.KeyValue {
- return GenAIAgentDescriptionKey.String(val)
-}
-
-// GenAIAgentID returns an attribute KeyValue conforming to the "gen_ai.agent.id"
-// semantic conventions. It represents the unique identifier of the GenAI agent.
-func GenAIAgentID(val string) attribute.KeyValue {
- return GenAIAgentIDKey.String(val)
-}
-
-// GenAIAgentName returns an attribute KeyValue conforming to the
-// "gen_ai.agent.name" semantic conventions. It represents the human-readable
-// name of the GenAI agent provided by the application.
-func GenAIAgentName(val string) attribute.KeyValue {
- return GenAIAgentNameKey.String(val)
-}
-
-// GenAIAgentVersion returns an attribute KeyValue conforming to the
-// "gen_ai.agent.version" semantic conventions. It represents the version of the
-// GenAI agent.
-func GenAIAgentVersion(val string) attribute.KeyValue {
- return GenAIAgentVersionKey.String(val)
-}
-
-// GenAIConversationID returns an attribute KeyValue conforming to the
-// "gen_ai.conversation.id" semantic conventions. It represents the unique
-// identifier for a conversation (session, thread), used to store and correlate
-// messages within this conversation.
-func GenAIConversationID(val string) attribute.KeyValue {
- return GenAIConversationIDKey.String(val)
-}
-
-// GenAIDataSourceID returns an attribute KeyValue conforming to the
-// "gen_ai.data_source.id" semantic conventions. It represents the data source
-// identifier.
-func GenAIDataSourceID(val string) attribute.KeyValue {
- return GenAIDataSourceIDKey.String(val)
-}
-
-// GenAIEmbeddingsDimensionCount returns an attribute KeyValue conforming to the
-// "gen_ai.embeddings.dimension.count" semantic conventions. It represents the
-// number of dimensions the resulting output embeddings should have.
-func GenAIEmbeddingsDimensionCount(val int) attribute.KeyValue {
- return GenAIEmbeddingsDimensionCountKey.Int(val)
-}
-
-// GenAIEvaluationExplanation returns an attribute KeyValue conforming to the
-// "gen_ai.evaluation.explanation" semantic conventions. It represents a
-// free-form explanation for the assigned score provided by the evaluator.
-func GenAIEvaluationExplanation(val string) attribute.KeyValue {
- return GenAIEvaluationExplanationKey.String(val)
-}
-
-// GenAIEvaluationName returns an attribute KeyValue conforming to the
-// "gen_ai.evaluation.name" semantic conventions. It represents the name of the
-// evaluation metric used for the GenAI response.
-func GenAIEvaluationName(val string) attribute.KeyValue {
- return GenAIEvaluationNameKey.String(val)
-}
-
-// GenAIEvaluationScoreLabel returns an attribute KeyValue conforming to the
-// "gen_ai.evaluation.score.label" semantic conventions. It represents the human
-// readable label for evaluation.
-func GenAIEvaluationScoreLabel(val string) attribute.KeyValue {
- return GenAIEvaluationScoreLabelKey.String(val)
-}
-
-// GenAIEvaluationScoreValue returns an attribute KeyValue conforming to the
-// "gen_ai.evaluation.score.value" semantic conventions. It represents the
-// evaluation score returned by the evaluator.
-func GenAIEvaluationScoreValue(val float64) attribute.KeyValue {
- return GenAIEvaluationScoreValueKey.Float64(val)
-}
-
-// GenAIPromptName returns an attribute KeyValue conforming to the
-// "gen_ai.prompt.name" semantic conventions. It represents the name of the
-// prompt that uniquely identifies it.
-func GenAIPromptName(val string) attribute.KeyValue {
- return GenAIPromptNameKey.String(val)
-}
-
-// GenAIRequestChoiceCount returns an attribute KeyValue conforming to the
-// "gen_ai.request.choice.count" semantic conventions. It represents the target
-// number of candidate completions to return.
-func GenAIRequestChoiceCount(val int) attribute.KeyValue {
- return GenAIRequestChoiceCountKey.Int(val)
-}
-
-// GenAIRequestEncodingFormats returns an attribute KeyValue conforming to the
-// "gen_ai.request.encoding_formats" semantic conventions. It represents the
-// encoding formats requested in an embeddings operation, if specified.
-func GenAIRequestEncodingFormats(val ...string) attribute.KeyValue {
- return GenAIRequestEncodingFormatsKey.StringSlice(val)
-}
-
-// GenAIRequestFrequencyPenalty returns an attribute KeyValue conforming to the
-// "gen_ai.request.frequency_penalty" semantic conventions. It represents the
-// frequency penalty setting for the GenAI request.
-func GenAIRequestFrequencyPenalty(val float64) attribute.KeyValue {
- return GenAIRequestFrequencyPenaltyKey.Float64(val)
-}
-
-// GenAIRequestMaxTokens returns an attribute KeyValue conforming to the
-// "gen_ai.request.max_tokens" semantic conventions. It represents the maximum
-// number of tokens the model generates for a request.
-func GenAIRequestMaxTokens(val int) attribute.KeyValue {
- return GenAIRequestMaxTokensKey.Int(val)
-}
-
-// GenAIRequestModel returns an attribute KeyValue conforming to the
-// "gen_ai.request.model" semantic conventions. It represents the name of the
-// GenAI model a request is being made to.
-func GenAIRequestModel(val string) attribute.KeyValue {
- return GenAIRequestModelKey.String(val)
-}
-
-// GenAIRequestPresencePenalty returns an attribute KeyValue conforming to the
-// "gen_ai.request.presence_penalty" semantic conventions. It represents the
-// presence penalty setting for the GenAI request.
-func GenAIRequestPresencePenalty(val float64) attribute.KeyValue {
- return GenAIRequestPresencePenaltyKey.Float64(val)
-}
-
-// GenAIRequestSeed returns an attribute KeyValue conforming to the
-// "gen_ai.request.seed" semantic conventions. It represents the requests with
-// same seed value more likely to return same result.
-func GenAIRequestSeed(val int) attribute.KeyValue {
- return GenAIRequestSeedKey.Int(val)
-}
-
-// GenAIRequestStopSequences returns an attribute KeyValue conforming to the
-// "gen_ai.request.stop_sequences" semantic conventions. It represents the list
-// of sequences that the model will use to stop generating further tokens.
-func GenAIRequestStopSequences(val ...string) attribute.KeyValue {
- return GenAIRequestStopSequencesKey.StringSlice(val)
-}
-
-// GenAIRequestStream returns an attribute KeyValue conforming to the
-// "gen_ai.request.stream" semantic conventions. It represents the indicates
-// whether the GenAI request was made in streaming mode.
-func GenAIRequestStream(val bool) attribute.KeyValue {
- return GenAIRequestStreamKey.Bool(val)
-}
-
-// GenAIRequestTemperature returns an attribute KeyValue conforming to the
-// "gen_ai.request.temperature" semantic conventions. It represents the
-// temperature setting for the GenAI request.
-func GenAIRequestTemperature(val float64) attribute.KeyValue {
- return GenAIRequestTemperatureKey.Float64(val)
-}
-
-// GenAIRequestTopK returns an attribute KeyValue conforming to the
-// "gen_ai.request.top_k" semantic conventions. It represents the top_k sampling
-// setting for the GenAI request.
-func GenAIRequestTopK(val float64) attribute.KeyValue {
- return GenAIRequestTopKKey.Float64(val)
-}
-
-// GenAIRequestTopP returns an attribute KeyValue conforming to the
-// "gen_ai.request.top_p" semantic conventions. It represents the top_p sampling
-// setting for the GenAI request.
-func GenAIRequestTopP(val float64) attribute.KeyValue {
- return GenAIRequestTopPKey.Float64(val)
-}
-
-// GenAIResponseFinishReasons returns an attribute KeyValue conforming to the
-// "gen_ai.response.finish_reasons" semantic conventions. It represents the array
-// of reasons the model stopped generating tokens, corresponding to each
-// generation received.
-func GenAIResponseFinishReasons(val ...string) attribute.KeyValue {
- return GenAIResponseFinishReasonsKey.StringSlice(val)
-}
-
-// GenAIResponseID returns an attribute KeyValue conforming to the
-// "gen_ai.response.id" semantic conventions. It represents the unique identifier
-// for the completion.
-func GenAIResponseID(val string) attribute.KeyValue {
- return GenAIResponseIDKey.String(val)
-}
-
-// GenAIResponseModel returns an attribute KeyValue conforming to the
-// "gen_ai.response.model" semantic conventions. It represents the name of the
-// model that generated the response.
-func GenAIResponseModel(val string) attribute.KeyValue {
- return GenAIResponseModelKey.String(val)
-}
-
-// GenAIResponseTimeToFirstChunk returns an attribute KeyValue conforming to the
-// "gen_ai.response.time_to_first_chunk" semantic conventions. It represents the
-// time to first chunk in a streaming response, measured from request issuance,
-// in seconds. The value is measured from when the client issues the generation
-// request to when the first chunk is received in the response stream.
-func GenAIResponseTimeToFirstChunk(val float64) attribute.KeyValue {
- return GenAIResponseTimeToFirstChunkKey.Float64(val)
-}
-
-// GenAIRetrievalQueryText returns an attribute KeyValue conforming to the
-// "gen_ai.retrieval.query.text" semantic conventions. It represents the query
-// text used for retrieval.
-func GenAIRetrievalQueryText(val string) attribute.KeyValue {
- return GenAIRetrievalQueryTextKey.String(val)
-}
-
-// GenAIToolCallID returns an attribute KeyValue conforming to the
-// "gen_ai.tool.call.id" semantic conventions. It represents the tool call
-// identifier.
-func GenAIToolCallID(val string) attribute.KeyValue {
- return GenAIToolCallIDKey.String(val)
-}
-
-// GenAIToolDescription returns an attribute KeyValue conforming to the
-// "gen_ai.tool.description" semantic conventions. It represents the tool
-// description.
-func GenAIToolDescription(val string) attribute.KeyValue {
- return GenAIToolDescriptionKey.String(val)
-}
-
-// GenAIToolName returns an attribute KeyValue conforming to the
-// "gen_ai.tool.name" semantic conventions. It represents the name of the tool
-// utilized by the agent.
-func GenAIToolName(val string) attribute.KeyValue {
- return GenAIToolNameKey.String(val)
-}
-
-// GenAIToolType returns an attribute KeyValue conforming to the
-// "gen_ai.tool.type" semantic conventions. It represents the type of the tool
-// utilized by the agent.
-func GenAIToolType(val string) attribute.KeyValue {
- return GenAIToolTypeKey.String(val)
-}
-
-// GenAIUsageCacheCreationInputTokens returns an attribute KeyValue conforming to
-// the "gen_ai.usage.cache_creation.input_tokens" semantic conventions. It
-// represents the number of input tokens written to a provider-managed cache.
-func GenAIUsageCacheCreationInputTokens(val int) attribute.KeyValue {
- return GenAIUsageCacheCreationInputTokensKey.Int(val)
-}
-
-// GenAIUsageCacheReadInputTokens returns an attribute KeyValue conforming to the
-// "gen_ai.usage.cache_read.input_tokens" semantic conventions. It represents the
-// number of input tokens served from a provider-managed cache.
-func GenAIUsageCacheReadInputTokens(val int) attribute.KeyValue {
- return GenAIUsageCacheReadInputTokensKey.Int(val)
-}
-
-// GenAIUsageInputTokens returns an attribute KeyValue conforming to the
-// "gen_ai.usage.input_tokens" semantic conventions. It represents the number of
-// tokens used in the GenAI input (prompt).
-func GenAIUsageInputTokens(val int) attribute.KeyValue {
- return GenAIUsageInputTokensKey.Int(val)
-}
-
-// GenAIUsageOutputTokens returns an attribute KeyValue conforming to the
-// "gen_ai.usage.output_tokens" semantic conventions. It represents the number of
-// tokens used in the GenAI response (completion).
-func GenAIUsageOutputTokens(val int) attribute.KeyValue {
- return GenAIUsageOutputTokensKey.Int(val)
-}
-
-// GenAIUsageReasoningOutputTokens returns an attribute KeyValue conforming to
-// the "gen_ai.usage.reasoning.output_tokens" semantic conventions. It represents
-// the number of output tokens used for reasoning (e.g. chain-of-thought,
-// extended thinking).
-func GenAIUsageReasoningOutputTokens(val int) attribute.KeyValue {
- return GenAIUsageReasoningOutputTokensKey.Int(val)
-}
-
-// GenAIWorkflowName returns an attribute KeyValue conforming to the
-// "gen_ai.workflow.name" semantic conventions. It represents the human-readable
-// name of the GenAI workflow provided by the application.
-func GenAIWorkflowName(val string) attribute.KeyValue {
- return GenAIWorkflowNameKey.String(val)
-}
-
-// Enum values for gen_ai.operation.name
-var (
- // Chat completion operation such as [OpenAI Chat API]
- // Stability: development
- //
- // [OpenAI Chat API]: https://platform.openai.com/docs/api-reference/chat
- GenAIOperationNameChat = GenAIOperationNameKey.String("chat")
- // Multimodal content generation operation such as [Gemini Generate Content]
- // Stability: development
- //
- // [Gemini Generate Content]: https://ai.google.dev/api/generate-content
- GenAIOperationNameGenerateContent = GenAIOperationNameKey.String("generate_content")
- // Text completions operation such as [OpenAI Completions API (Legacy)]
- // Stability: development
- //
- // [OpenAI Completions API (Legacy)]: https://platform.openai.com/docs/api-reference/completions
- GenAIOperationNameTextCompletion = GenAIOperationNameKey.String("text_completion")
- // Embeddings operation such as [OpenAI Create embeddings API]
- // Stability: development
- //
- // [OpenAI Create embeddings API]: https://platform.openai.com/docs/api-reference/embeddings/create
- GenAIOperationNameEmbeddings = GenAIOperationNameKey.String("embeddings")
- // Retrieval operation such as [OpenAI Search Vector Store API]
- // Stability: development
- //
- // [OpenAI Search Vector Store API]: https://platform.openai.com/docs/api-reference/vector-stores/search
- GenAIOperationNameRetrieval = GenAIOperationNameKey.String("retrieval")
- // Create GenAI agent
- // Stability: development
- GenAIOperationNameCreateAgent = GenAIOperationNameKey.String("create_agent")
- // Invoke GenAI agent
- // Stability: development
- GenAIOperationNameInvokeAgent = GenAIOperationNameKey.String("invoke_agent")
- // Execute a tool
- // Stability: development
- GenAIOperationNameExecuteTool = GenAIOperationNameKey.String("execute_tool")
- // Invoke GenAI workflow
- // Stability: development
- GenAIOperationNameInvokeWorkflow = GenAIOperationNameKey.String("invoke_workflow")
-)
-
-// Enum values for gen_ai.output.type
-var (
- // Plain text
- // Stability: development
- GenAIOutputTypeText = GenAIOutputTypeKey.String("text")
- // JSON object with known or unknown schema
- // Stability: development
- GenAIOutputTypeJSON = GenAIOutputTypeKey.String("json")
- // Image
- // Stability: development
- GenAIOutputTypeImage = GenAIOutputTypeKey.String("image")
- // Speech
- // Stability: development
- GenAIOutputTypeSpeech = GenAIOutputTypeKey.String("speech")
-)
-
-// Enum values for gen_ai.provider.name
-var (
- // [OpenAI]
- // Stability: development
- //
- // [OpenAI]: https://openai.com/
- GenAIProviderNameOpenAI = GenAIProviderNameKey.String("openai")
- // Any Google generative AI endpoint
- // Stability: development
- GenAIProviderNameGCPGenAI = GenAIProviderNameKey.String("gcp.gen_ai")
- // [Vertex AI]
- // Stability: development
- //
- // [Vertex AI]: https://cloud.google.com/vertex-ai
- GenAIProviderNameGCPVertexAI = GenAIProviderNameKey.String("gcp.vertex_ai")
- // [Gemini]
- // Stability: development
- //
- // [Gemini]: https://cloud.google.com/products/gemini
- GenAIProviderNameGCPGemini = GenAIProviderNameKey.String("gcp.gemini")
- // [Anthropic]
- // Stability: development
- //
- // [Anthropic]: https://www.anthropic.com/
- GenAIProviderNameAnthropic = GenAIProviderNameKey.String("anthropic")
- // [Cohere]
- // Stability: development
- //
- // [Cohere]: https://cohere.com/
- GenAIProviderNameCohere = GenAIProviderNameKey.String("cohere")
- // Azure AI Inference
- // Stability: development
- GenAIProviderNameAzureAIInference = GenAIProviderNameKey.String("azure.ai.inference")
- // [Azure OpenAI]
- // Stability: development
- //
- // [Azure OpenAI]: https://learn.microsoft.com/en-us/azure/ai-services/openai/overview
- GenAIProviderNameAzureAIOpenAI = GenAIProviderNameKey.String("azure.ai.openai")
- // [IBM Watsonx AI]
- // Stability: development
- //
- // [IBM Watsonx AI]: https://www.ibm.com/products/watsonx-ai
- GenAIProviderNameIBMWatsonxAI = GenAIProviderNameKey.String("ibm.watsonx.ai")
- // [AWS Bedrock]
- // Stability: development
- //
- // [AWS Bedrock]: https://aws.amazon.com/bedrock
- GenAIProviderNameAWSBedrock = GenAIProviderNameKey.String("aws.bedrock")
- // [Perplexity]
- // Stability: development
- //
- // [Perplexity]: https://www.perplexity.ai/
- GenAIProviderNamePerplexity = GenAIProviderNameKey.String("perplexity")
- // [xAI]
- // Stability: development
- //
- // [xAI]: https://x.ai/
- GenAIProviderNameXAI = GenAIProviderNameKey.String("x_ai")
- // [DeepSeek]
- // Stability: development
- //
- // [DeepSeek]: https://www.deepseek.com/
- GenAIProviderNameDeepseek = GenAIProviderNameKey.String("deepseek")
- // [Groq]
- // Stability: development
- //
- // [Groq]: https://groq.com/
- GenAIProviderNameGroq = GenAIProviderNameKey.String("groq")
- // [Mistral AI]
- // Stability: development
- //
- // [Mistral AI]: https://mistral.ai/
- GenAIProviderNameMistralAI = GenAIProviderNameKey.String("mistral_ai")
-)
-
-// Enum values for gen_ai.token.type
-var (
- // Input tokens (prompt, input, etc.)
- // Stability: development
- GenAITokenTypeInput = GenAITokenTypeKey.String("input")
- // Output tokens (completion, response, etc.)
- // Stability: development
- GenAITokenTypeOutput = GenAITokenTypeKey.String("output")
-)
-
-// Namespace: geo
-const (
- // GeoContinentCodeKey is the attribute Key conforming to the
- // "geo.continent.code" semantic conventions. It represents the two-letter code
- // representing continent’s name.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- GeoContinentCodeKey = attribute.Key("geo.continent.code")
-
- // GeoCountryISOCodeKey is the attribute Key conforming to the
- // "geo.country.iso_code" semantic conventions. It represents the two-letter ISO
- // Country Code ([ISO 3166-1 alpha2]).
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "CA"
- //
- // [ISO 3166-1 alpha2]: https://wikipedia.org/wiki/ISO_3166-1#Codes
- GeoCountryISOCodeKey = attribute.Key("geo.country.iso_code")
-
- // GeoLocalityNameKey is the attribute Key conforming to the "geo.locality.name"
- // semantic conventions. It represents the locality name. Represents the name of
- // a city, town, village, or similar populated place.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "Montreal", "Berlin"
- GeoLocalityNameKey = attribute.Key("geo.locality.name")
-
- // GeoLocationLatKey is the attribute Key conforming to the "geo.location.lat"
- // semantic conventions. It represents the latitude of the geo location in
- // [WGS84].
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: 45.505918
- //
- // [WGS84]: https://wikipedia.org/wiki/World_Geodetic_System#WGS84
- GeoLocationLatKey = attribute.Key("geo.location.lat")
-
- // GeoLocationLonKey is the attribute Key conforming to the "geo.location.lon"
- // semantic conventions. It represents the longitude of the geo location in
- // [WGS84].
- //
- // Type: double
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: -73.61483
- //
- // [WGS84]: https://wikipedia.org/wiki/World_Geodetic_System#WGS84
- GeoLocationLonKey = attribute.Key("geo.location.lon")
-
- // GeoPostalCodeKey is the attribute Key conforming to the "geo.postal_code"
- // semantic conventions. It represents the postal code associated with the
- // location. Values appropriate for this field may also be known as a postcode
- // or ZIP code and will vary widely from country to country.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "94040"
- GeoPostalCodeKey = attribute.Key("geo.postal_code")
-
- // GeoRegionISOCodeKey is the attribute Key conforming to the
- // "geo.region.iso_code" semantic conventions. It represents the region ISO code
- // ([ISO 3166-2]).
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "CA-QC"
- //
- // [ISO 3166-2]: https://wikipedia.org/wiki/ISO_3166-2
- GeoRegionISOCodeKey = attribute.Key("geo.region.iso_code")
-)
+ // [ISO 3166-2]: https://wikipedia.org/wiki/ISO_3166-2
+ GeoRegionISOCodeKey = attribute.Key("geo.region.iso_code")
+)
// GeoCountryISOCode returns an attribute KeyValue conforming to the
// "geo.country.iso_code" semantic conventions. It represents the two-letter ISO
@@ -9201,7 +8198,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry-cluster"
K8SClusterNameKey = attribute.Key("k8s.cluster.name")
@@ -9212,7 +8209,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "218fc5a9-a5f1-4b54-aa05-46717d0ab26d"
// Note: K8s doesn't have support for obtaining a cluster ID. If this is ever
@@ -9241,6 +8238,19 @@ const (
// [ISO/IEC 9834-8 and ITU-T X.667]: https://www.itu.int/ITU-T/studygroups/com17/oid.html
K8SClusterUIDKey = attribute.Key("k8s.cluster.uid")
+ // K8SContainerEphemeralStorageFsTypeKey is the attribute Key conforming to the
+ // "k8s.container.ephemeral_storage.fs_type" semantic conventions. It represents
+ // the type of file system component for ephemeral storage.
+ //
+ // Type: Enum
+ // RequirementLevel: Recommended
+ // Stability: Development
+ //
+ // Examples: "rootfs", "logs"
+ // Note: Eviction decisions based on ephemeral-storage resource limits are made
+ // based on the total container usage.
+ K8SContainerEphemeralStorageFsTypeKey = attribute.Key("k8s.container.ephemeral_storage.fs_type")
+
// K8SContainerNameKey is the attribute Key conforming to the
// "k8s.container.name" semantic conventions. It represents the name of the
// Container from Pod specification, must be unique within a Pod. Container
@@ -9248,7 +8258,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "redis"
K8SContainerNameKey = attribute.Key("k8s.container.name")
@@ -9260,7 +8270,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples:
K8SContainerRestartCountKey = attribute.Key("k8s.container.restart_count")
@@ -9289,8 +8299,8 @@ const (
// "CreateContainerConfigError", "ErrImagePull", "ImagePullBackOff",
// "OOMKilled", "Completed", "Error", "ContainerCannotRun"
//
- // [K8s ContainerStateWaiting]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#containerstatewaiting-v1-core
- // [K8s ContainerStateTerminated]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#containerstateterminated-v1-core
+ // [K8s ContainerStateWaiting]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#containerstatewaiting-v1-core
+ // [K8s ContainerStateTerminated]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#containerstateterminated-v1-core
K8SContainerStatusReasonKey = attribute.Key("k8s.container.status.reason")
// K8SContainerStatusStateKey is the attribute Key conforming to the
@@ -9303,7 +8313,7 @@ const (
//
// Examples: "terminated", "running", "waiting"
//
- // [K8s ContainerState]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#containerstate-v1-core
+ // [K8s ContainerState]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#containerstate-v1-core
K8SContainerStatusStateKey = attribute.Key("k8s.container.status.state")
// K8SCronJobNameKey is the attribute Key conforming to the "k8s.cronjob.name"
@@ -9311,7 +8321,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry"
K8SCronJobNameKey = attribute.Key("k8s.cronjob.name")
@@ -9321,7 +8331,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SCronJobUIDKey = attribute.Key("k8s.cronjob.uid")
@@ -9332,7 +8342,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry"
K8SDaemonSetNameKey = attribute.Key("k8s.daemonset.name")
@@ -9342,7 +8352,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SDaemonSetUIDKey = attribute.Key("k8s.daemonset.uid")
@@ -9353,7 +8363,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry"
K8SDeploymentNameKey = attribute.Key("k8s.deployment.name")
@@ -9364,7 +8374,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SDeploymentUIDKey = attribute.Key("k8s.deployment.uid")
@@ -9454,7 +8464,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry"
K8SJobNameKey = attribute.Key("k8s.job.name")
@@ -9464,7 +8474,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SJobUIDKey = attribute.Key("k8s.job.uid")
@@ -9475,7 +8485,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "default"
K8SNamespaceNameKey = attribute.Key("k8s.namespace.name")
@@ -9492,7 +8502,7 @@ const (
// Note: This attribute aligns with the `phase` field of the
// [K8s NamespaceStatus]
//
- // [K8s NamespaceStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#namespacestatus-v1-core
+ // [K8s NamespaceStatus]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#namespacestatus-v1-core
K8SNamespacePhaseKey = attribute.Key("k8s.namespace.phase")
// K8SNodeConditionStatusKey is the attribute Key conforming to the
@@ -9507,7 +8517,7 @@ const (
// Note: This attribute aligns with the `status` field of the
// [NodeCondition]
//
- // [NodeCondition]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#nodecondition-v1-core
+ // [NodeCondition]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#nodecondition-v1-core
K8SNodeConditionStatusKey = attribute.Key("k8s.node.condition.status")
// K8SNodeConditionTypeKey is the attribute Key conforming to the
@@ -9531,8 +8541,8 @@ const (
// When this occurs, the exact value as reported by the Kubernetes API SHOULD be
// used.
//
- // [K8s documentation]: https://v1-32.docs.kubernetes.io/docs/reference/node/node-status/#condition
- // [NodeCondition]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#nodecondition-v1-core
+ // [K8s documentation]: https://kubernetes.io/docs/reference/node/node-status/#condition
+ // [NodeCondition]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#nodecondition-v1-core
K8SNodeConditionTypeKey = attribute.Key("k8s.node.condition.type")
// K8SNodeNameKey is the attribute Key conforming to the "k8s.node.name"
@@ -9540,7 +8550,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "node-1"
K8SNodeNameKey = attribute.Key("k8s.node.name")
@@ -9561,7 +8571,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "1eb3a0c6-0477-4080-a9cb-0cb7db65c6a2"
K8SNodeUIDKey = attribute.Key("k8s.node.uid")
@@ -9661,7 +8671,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "collector-gateway"
// Note: The K8s Pod spec has an optional hostname field, which can be used to
@@ -9681,7 +8691,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "172.18.0.2"
// Note: This attribute aligns with the `podIP` field of the
@@ -9695,7 +8705,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry-pod-autoconf"
K8SPodNameKey = attribute.Key("k8s.pod.name")
@@ -9706,7 +8716,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "2025-12-04T08:41:03Z"
// Note: Date and time at which the object was acknowledged by the Kubelet.
@@ -9750,7 +8760,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SPodUIDKey = attribute.Key("k8s.pod.uid")
@@ -9761,7 +8771,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry"
K8SReplicaSetNameKey = attribute.Key("k8s.replicaset.name")
@@ -9772,7 +8782,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SReplicaSetUIDKey = attribute.Key("k8s.replicaset.uid")
@@ -9985,7 +8995,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "opentelemetry"
K8SStatefulSetNameKey = attribute.Key("k8s.statefulset.name")
@@ -9996,7 +9006,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Release_Candidate
+ // Stability: Stable
//
// Examples: "275ecb36-5aa8-4c2a-9c47-d8bb681b9aff"
K8SStatefulSetUIDKey = attribute.Key("k8s.statefulset.uid")
@@ -10011,7 +9021,7 @@ const (
//
// Examples: "gold.storageclass.storage.k8s.io"
//
- // [StorageClass]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#storageclass-v1-storage-k8s-io
+ // [StorageClass]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#storageclass-v1-storage-k8s-io
K8SStorageclassNameKey = attribute.Key("k8s.storageclass.name")
// K8SVolumeNameKey is the attribute Key conforming to the "k8s.volume.name"
@@ -10559,7 +9569,7 @@ func K8SStatefulSetUID(val string) attribute.KeyValue {
// "k8s.storageclass.name" semantic conventions. It represents the name of K8s
// [StorageClass] object.
//
-// [StorageClass]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.30/#storageclass-v1-storage-k8s-io
+// [StorageClass]: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.34/#storageclass-v1-storage-k8s-io
func K8SStorageclassName(val string) attribute.KeyValue {
return K8SStorageclassNameKey.String(val)
}
@@ -10571,6 +9581,16 @@ func K8SVolumeName(val string) attribute.KeyValue {
return K8SVolumeNameKey.String(val)
}
+// Enum values for k8s.container.ephemeral_storage.fs_type
+var (
+ // For the container's writable layer usage.
+ // Stability: development
+ K8SContainerEphemeralStorageFsTypeRootfs = K8SContainerEphemeralStorageFsTypeKey.String("rootfs")
+ // For the container's log files usage (stdout/stderr).
+ // Stability: development
+ K8SContainerEphemeralStorageFsTypeLogs = K8SContainerEphemeralStorageFsTypeKey.String("logs")
+)
+
// Enum values for k8s.container.status.reason
var (
// The container is being created.
@@ -10809,32 +9829,32 @@ var (
// A [persistentVolumeClaim] volume
// Stability: development
//
- // [persistentVolumeClaim]: https://v1-30.docs.kubernetes.io/docs/concepts/storage/volumes/#persistentvolumeclaim
+ // [persistentVolumeClaim]: https://kubernetes.io/docs/concepts/storage/volumes/#persistentvolumeclaim
K8SVolumeTypePersistentVolumeClaim = K8SVolumeTypeKey.String("persistentVolumeClaim")
// A [configMap] volume
// Stability: development
//
- // [configMap]: https://v1-30.docs.kubernetes.io/docs/concepts/storage/volumes/#configmap
+ // [configMap]: https://kubernetes.io/docs/concepts/storage/volumes/#configmap
K8SVolumeTypeConfigMap = K8SVolumeTypeKey.String("configMap")
// A [downwardAPI] volume
// Stability: development
//
- // [downwardAPI]: https://v1-30.docs.kubernetes.io/docs/concepts/storage/volumes/#downwardapi
+ // [downwardAPI]: https://kubernetes.io/docs/concepts/storage/volumes/#downwardapi
K8SVolumeTypeDownwardAPI = K8SVolumeTypeKey.String("downwardAPI")
// An [emptyDir] volume
// Stability: development
//
- // [emptyDir]: https://v1-30.docs.kubernetes.io/docs/concepts/storage/volumes/#emptydir
+ // [emptyDir]: https://kubernetes.io/docs/concepts/storage/volumes/#emptydir
K8SVolumeTypeEmptyDir = K8SVolumeTypeKey.String("emptyDir")
// A [secret] volume
// Stability: development
//
- // [secret]: https://v1-30.docs.kubernetes.io/docs/concepts/storage/volumes/#secret
+ // [secret]: https://kubernetes.io/docs/concepts/storage/volumes/#secret
K8SVolumeTypeSecret = K8SVolumeTypeKey.String("secret")
// A [local] volume
// Stability: development
//
- // [local]: https://v1-30.docs.kubernetes.io/docs/concepts/storage/volumes/#local
+ // [local]: https://kubernetes.io/docs/concepts/storage/volumes/#local
K8SVolumeTypeLocal = K8SVolumeTypeKey.String("local")
)
@@ -10959,227 +9979,45 @@ func LogFilePathResolved(val string) attribute.KeyValue {
// original Log Record.
func LogRecordOriginal(val string) attribute.KeyValue {
return LogRecordOriginalKey.String(val)
-}
-
-// LogRecordUID returns an attribute KeyValue conforming to the "log.record.uid"
-// semantic conventions. It represents a unique identifier for the Log Record.
-func LogRecordUID(val string) attribute.KeyValue {
- return LogRecordUIDKey.String(val)
-}
-
-// Enum values for log.iostream
-var (
- // Logs from stdout stream
- // Stability: development
- LogIostreamStdout = LogIostreamKey.String("stdout")
- // Events from stderr stream
- // Stability: development
- LogIostreamStderr = LogIostreamKey.String("stderr")
-)
-
-// Namespace: mainframe
-const (
- // MainframeLparNameKey is the attribute Key conforming to the
- // "mainframe.lpar.name" semantic conventions. It represents the name of the
- // logical partition that hosts a systems with a mainframe operating system.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "LPAR01"
- MainframeLparNameKey = attribute.Key("mainframe.lpar.name")
-)
-
-// MainframeLparName returns an attribute KeyValue conforming to the
-// "mainframe.lpar.name" semantic conventions. It represents the name of the
-// logical partition that hosts a systems with a mainframe operating system.
-func MainframeLparName(val string) attribute.KeyValue {
- return MainframeLparNameKey.String(val)
-}
-
-// Namespace: mcp
-const (
- // McpMethodNameKey is the attribute Key conforming to the "mcp.method.name"
- // semantic conventions. It represents the name of the request or notification
- // method.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- McpMethodNameKey = attribute.Key("mcp.method.name")
-
- // McpProtocolVersionKey is the attribute Key conforming to the
- // "mcp.protocol.version" semantic conventions. It represents the [version] of
- // the Model Context Protocol used.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "2025-06-18"
- //
- // [version]: https://modelcontextprotocol.io/specification/versioning
- McpProtocolVersionKey = attribute.Key("mcp.protocol.version")
-
- // McpResourceURIKey is the attribute Key conforming to the "mcp.resource.uri"
- // semantic conventions. It represents the value of the resource uri.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "postgres://database/customers/schema",
- // "file:///home/user/documents/report.pdf"
- // Note: This is a URI of the resource provided in the following requests or
- // notifications: `resources/read`, `resources/subscribe`,
- // `resources/unsubscribe`, or `notifications/resources/updated`.
- McpResourceURIKey = attribute.Key("mcp.resource.uri")
-
- // McpSessionIDKey is the attribute Key conforming to the "mcp.session.id"
- // semantic conventions. It represents the identifies [MCP session].
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "191c4850af6c49e08843a3f6c80e5046"
- //
- // [MCP session]: https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#session-management
- McpSessionIDKey = attribute.Key("mcp.session.id")
-)
-
-// McpProtocolVersion returns an attribute KeyValue conforming to the
-// "mcp.protocol.version" semantic conventions. It represents the [version] of
-// the Model Context Protocol used.
-//
-// [version]: https://modelcontextprotocol.io/specification/versioning
-func McpProtocolVersion(val string) attribute.KeyValue {
- return McpProtocolVersionKey.String(val)
-}
-
-// McpResourceURI returns an attribute KeyValue conforming to the
-// "mcp.resource.uri" semantic conventions. It represents the value of the
-// resource uri.
-func McpResourceURI(val string) attribute.KeyValue {
- return McpResourceURIKey.String(val)
-}
-
-// McpSessionID returns an attribute KeyValue conforming to the "mcp.session.id"
-// semantic conventions. It represents the identifies [MCP session].
-//
-// [MCP session]: https://modelcontextprotocol.io/specification/2025-06-18/basic/transports#session-management
-func McpSessionID(val string) attribute.KeyValue {
- return McpSessionIDKey.String(val)
-}
-
-// Enum values for mcp.method.name
-var (
- // Notification cancelling a previously-issued request.
- //
- // Stability: development
- McpMethodNameNotificationsCancelled = McpMethodNameKey.String("notifications/cancelled")
- // Request to initialize the MCP client.
- //
- // Stability: development
- McpMethodNameInitialize = McpMethodNameKey.String("initialize")
- // Notification indicating that the MCP client has been initialized.
- //
- // Stability: development
- McpMethodNameNotificationsInitialized = McpMethodNameKey.String("notifications/initialized")
- // Notification indicating the progress for a long-running operation.
- //
- // Stability: development
- McpMethodNameNotificationsProgress = McpMethodNameKey.String("notifications/progress")
- // Request to check that the other party is still alive.
- //
- // Stability: development
- McpMethodNamePing = McpMethodNameKey.String("ping")
- // Request to list resources available on server.
- //
- // Stability: development
- McpMethodNameResourcesList = McpMethodNameKey.String("resources/list")
- // Request to list resource templates available on server.
- //
- // Stability: development
- McpMethodNameResourcesTemplatesList = McpMethodNameKey.String("resources/templates/list")
- // Request to read a resource.
- //
- // Stability: development
- McpMethodNameResourcesRead = McpMethodNameKey.String("resources/read")
- // Notification indicating that the list of resources has changed.
- //
- // Stability: development
- McpMethodNameNotificationsResourcesListChanged = McpMethodNameKey.String("notifications/resources/list_changed")
- // Request to subscribe to a resource.
- //
- // Stability: development
- McpMethodNameResourcesSubscribe = McpMethodNameKey.String("resources/subscribe")
- // Request to unsubscribe from resource updates.
- //
- // Stability: development
- McpMethodNameResourcesUnsubscribe = McpMethodNameKey.String("resources/unsubscribe")
- // Notification indicating that a resource has been updated.
- //
- // Stability: development
- McpMethodNameNotificationsResourcesUpdated = McpMethodNameKey.String("notifications/resources/updated")
- // Request to list prompts available on server.
- //
- // Stability: development
- McpMethodNamePromptsList = McpMethodNameKey.String("prompts/list")
- // Request to get a prompt.
- //
- // Stability: development
- McpMethodNamePromptsGet = McpMethodNameKey.String("prompts/get")
- // Notification indicating that the list of prompts has changed.
- //
- // Stability: development
- McpMethodNameNotificationsPromptsListChanged = McpMethodNameKey.String("notifications/prompts/list_changed")
- // Request to list tools available on server.
- //
- // Stability: development
- McpMethodNameToolsList = McpMethodNameKey.String("tools/list")
- // Request to call a tool.
- //
- // Stability: development
- McpMethodNameToolsCall = McpMethodNameKey.String("tools/call")
- // Notification indicating that the list of tools has changed.
- //
- // Stability: development
- McpMethodNameNotificationsToolsListChanged = McpMethodNameKey.String("notifications/tools/list_changed")
- // Request to set the logging level.
- //
- // Stability: development
- McpMethodNameLoggingSetLevel = McpMethodNameKey.String("logging/setLevel")
- // Notification indicating that a message has been received.
- //
- // Stability: development
- McpMethodNameNotificationsMessage = McpMethodNameKey.String("notifications/message")
- // Request to create a sampling message.
- //
- // Stability: development
- McpMethodNameSamplingCreateMessage = McpMethodNameKey.String("sampling/createMessage")
- // Request to complete a prompt.
- //
+}
+
+// LogRecordUID returns an attribute KeyValue conforming to the "log.record.uid"
+// semantic conventions. It represents a unique identifier for the Log Record.
+func LogRecordUID(val string) attribute.KeyValue {
+ return LogRecordUIDKey.String(val)
+}
+
+// Enum values for log.iostream
+var (
+ // Logs from stdout stream
// Stability: development
- McpMethodNameCompletionComplete = McpMethodNameKey.String("completion/complete")
- // Request to list roots available on server.
- //
+ LogIostreamStdout = LogIostreamKey.String("stdout")
+ // Events from stderr stream
// Stability: development
- McpMethodNameRootsList = McpMethodNameKey.String("roots/list")
- // Notification indicating that the list of roots has changed.
+ LogIostreamStderr = LogIostreamKey.String("stderr")
+)
+
+// Namespace: mainframe
+const (
+ // MainframeLparNameKey is the attribute Key conforming to the
+ // "mainframe.lpar.name" semantic conventions. It represents the name of the
+ // logical partition that hosts a systems with a mainframe operating system.
//
- // Stability: development
- McpMethodNameNotificationsRootsListChanged = McpMethodNameKey.String("notifications/roots/list_changed")
- // Request from the server to elicit additional information from the user via
- // the client
+ // Type: string
+ // RequirementLevel: Recommended
+ // Stability: Development
//
- // Stability: development
- McpMethodNameElicitationCreate = McpMethodNameKey.String("elicitation/create")
+ // Examples: "LPAR01"
+ MainframeLparNameKey = attribute.Key("mainframe.lpar.name")
)
+// MainframeLparName returns an attribute KeyValue conforming to the
+// "mainframe.lpar.name" semantic conventions. It represents the name of the
+// logical partition that hosts a systems with a mainframe operating system.
+func MainframeLparName(val string) attribute.KeyValue {
+ return MainframeLparNameKey.String(val)
+}
+
// Namespace: messaging
const (
// MessagingBatchMessageCountKey is the attribute Key conforming to the
@@ -12073,12 +10911,14 @@ const (
NetworkInterfaceNameKey = attribute.Key("network.interface.name")
// NetworkIODirectionKey is the attribute Key conforming to the
- // "network.io.direction" semantic conventions. It represents the network IO
- // operation direction.
+ // "network.io.direction" semantic conventions. It represents the direction of
+ // traffic from the perspective of the observing host's physical or virtual
+ // network interface. It should not be used to represent the logical direction
+ // of a stateful connection or network flow.
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "transmit"
NetworkIODirectionKey = attribute.Key("network.io.direction")
@@ -12395,10 +11235,10 @@ var (
// Enum values for network.io.direction
var (
// transmit
- // Stability: development
+ // Stability: release_candidate
NetworkIODirectionTransmit = NetworkIODirectionKey.String("transmit")
// receive
- // Stability: development
+ // Stability: release_candidate
NetworkIODirectionReceive = NetworkIODirectionKey.String("receive")
)
@@ -12577,90 +11417,6 @@ func OncRPCVersion(val int) attribute.KeyValue {
return OncRPCVersionKey.Int(val)
}
-// Namespace: openai
-const (
- // OpenAIAPITypeKey is the attribute Key conforming to the "openai.api.type"
- // semantic conventions. It represents the type of OpenAI API being used.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples:
- OpenAIAPITypeKey = attribute.Key("openai.api.type")
-
- // OpenAIRequestServiceTierKey is the attribute Key conforming to the
- // "openai.request.service_tier" semantic conventions. It represents the service
- // tier requested. May be a specific tier, default, or auto.
- //
- // Type: Enum
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "auto", "default"
- OpenAIRequestServiceTierKey = attribute.Key("openai.request.service_tier")
-
- // OpenAIResponseServiceTierKey is the attribute Key conforming to the
- // "openai.response.service_tier" semantic conventions. It represents the
- // service tier used for the response.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "scale", "default"
- OpenAIResponseServiceTierKey = attribute.Key("openai.response.service_tier")
-
- // OpenAIResponseSystemFingerprintKey is the attribute Key conforming to the
- // "openai.response.system_fingerprint" semantic conventions. It represents a
- // fingerprint to track any eventual change in the Generative AI environment.
- //
- // Type: string
- // RequirementLevel: Recommended
- // Stability: Development
- //
- // Examples: "fp_44709d6fcb"
- OpenAIResponseSystemFingerprintKey = attribute.Key("openai.response.system_fingerprint")
-)
-
-// OpenAIResponseServiceTier returns an attribute KeyValue conforming to the
-// "openai.response.service_tier" semantic conventions. It represents the service
-// tier used for the response.
-func OpenAIResponseServiceTier(val string) attribute.KeyValue {
- return OpenAIResponseServiceTierKey.String(val)
-}
-
-// OpenAIResponseSystemFingerprint returns an attribute KeyValue conforming to
-// the "openai.response.system_fingerprint" semantic conventions. It represents a
-// fingerprint to track any eventual change in the Generative AI environment.
-func OpenAIResponseSystemFingerprint(val string) attribute.KeyValue {
- return OpenAIResponseSystemFingerprintKey.String(val)
-}
-
-// Enum values for openai.api.type
-var (
- // The OpenAI [Chat Completions API].
- // Stability: development
- //
- // [Chat Completions API]: https://developers.openai.com/api/reference/chat-completions/overview
- OpenAIAPITypeChatCompletions = OpenAIAPITypeKey.String("chat_completions")
- // The OpenAI [Responses API].
- // Stability: development
- //
- // [Responses API]: https://developers.openai.com/api/reference/responses/overview
- OpenAIAPITypeResponses = OpenAIAPITypeKey.String("responses")
-)
-
-// Enum values for openai.request.service_tier
-var (
- // The system will utilize scale tier credits until they are exhausted.
- // Stability: development
- OpenAIRequestServiceTierAuto = OpenAIRequestServiceTierKey.String("auto")
- // The system will utilize the default scale tier.
- // Stability: development
- OpenAIRequestServiceTierDefault = OpenAIRequestServiceTierKey.String("default")
-)
-
// Namespace: openshift
const (
// OpenShiftClusterquotaNameKey is the attribute Key conforming to the
@@ -12733,7 +11489,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "example.com", "corp.internal", "prod.db.local"
// Note: This attribute SHOULD be set to the value of the `DB_DOMAIN`
@@ -12753,7 +11509,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "ORCL1", "ORCL2", "ORCL3"
// Note: There can be multiple instances associated with a single database
@@ -12769,7 +11525,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "ORCL1", "FREE"
// Note: This attribute SHOULD be set to the value of the parameter `DB_NAME`
@@ -12782,7 +11538,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "PDB1", "FREEPDB"
// Note: This attribute SHOULD reflect the PDB that the session is currently
@@ -12800,7 +11556,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "order-processing-service", "db_low.adb.oraclecloud.com",
// "db_high.adb.oraclecloud.com"
@@ -13529,7 +12285,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 4
// Note: This field can be useful for querying or performing bucket analysis on
@@ -13545,7 +12301,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "cmd/otelcol"
ProcessCommandKey = attribute.Key("process.command")
@@ -13561,7 +12317,7 @@ const (
//
// Type: string[]
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "cmd/otecol", "--config=config.yaml"
ProcessCommandArgsKey = attribute.Key("process.command_args")
@@ -13576,7 +12332,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "C:\cmd\otecol --config="my directory\config.yaml""
ProcessCommandLineKey = attribute.Key("process.command_line")
@@ -13588,7 +12344,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples:
ProcessContextSwitchTypeKey = attribute.Key("process.context_switch.type")
@@ -13599,7 +12355,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "2023-11-21T09:25:34.853Z"
ProcessCreationTimeKey = attribute.Key("process.creation.time")
@@ -13610,7 +12366,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "c89b11207f6479603b0d49bf291c092c2b719293"
ProcessExecutableBuildIDGNUKey = attribute.Key("process.executable.build_id.gnu")
@@ -13621,7 +12377,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples:
// "foh3mEXu7BLZjsN9pOwG/kATcXlYVCDEFouRMQed_/WwRFB1hPo9LBkekthSPG/x8hMC8emW2cCjXD0_1aY"
@@ -13633,7 +12389,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "600DCAFE4A110000F2BF38C493F5FB92"
// Note: GNU and Go build IDs may be stripped or unavailable in some
@@ -13660,7 +12416,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "otelcol"
ProcessExecutableNameKey = attribute.Key("process.executable.name")
@@ -13673,7 +12429,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "/usr/bin/cmd/otelcol"
ProcessExecutablePathKey = attribute.Key("process.executable.path")
@@ -13683,7 +12439,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 127
ProcessExitCodeKey = attribute.Key("process.exit.code")
@@ -13694,7 +12450,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "2023-11-21T09:26:12.315Z"
ProcessExitTimeKey = attribute.Key("process.exit.time")
@@ -13706,7 +12462,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 23
ProcessGroupLeaderPIDKey = attribute.Key("process.group_leader.pid")
@@ -13717,7 +12473,7 @@ const (
//
// Type: boolean
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples:
ProcessInteractiveKey = attribute.Key("process.interactive")
@@ -13728,7 +12484,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "1:name=systemd:/user.slice/user-1000.slice/session-3.scope",
// "0::/user.slice/user-1000.slice/user@1000.service/tmux-spawn-0267755b-4639-4a27-90ed-f19f88e53748.scope"
@@ -13746,7 +12502,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "root"
ProcessOwnerKey = attribute.Key("process.owner")
@@ -13757,7 +12513,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 111
ProcessParentPIDKey = attribute.Key("process.parent_pid")
@@ -13767,7 +12523,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 1234
ProcessPIDKey = attribute.Key("process.pid")
@@ -13778,7 +12534,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 1000
ProcessRealUserIDKey = attribute.Key("process.real_user.id")
@@ -13789,7 +12545,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "operator"
ProcessRealUserNameKey = attribute.Key("process.real_user.name")
@@ -13801,7 +12557,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: Eclipse OpenJ9 Eclipse OpenJ9 VM openj9-0.21.0
ProcessRuntimeDescriptionKey = attribute.Key("process.runtime.description")
@@ -13812,7 +12568,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "OpenJDK Runtime Environment"
ProcessRuntimeNameKey = attribute.Key("process.runtime.name")
@@ -13823,7 +12579,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 14.0.2
ProcessRuntimeVersionKey = attribute.Key("process.runtime.version")
@@ -13834,7 +12590,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 1002
ProcessSavedUserIDKey = attribute.Key("process.saved_user.id")
@@ -13845,7 +12601,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "operator"
ProcessSavedUserNameKey = attribute.Key("process.saved_user.name")
@@ -13857,7 +12613,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 14
ProcessSessionLeaderPIDKey = attribute.Key("process.session_leader.pid")
@@ -13868,7 +12624,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "running"
//
@@ -13880,7 +12636,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "cat /etc/hostname", "xfce4-session", "bash"
// Note: In many Unix-like systems, process title (proctitle), is the string
@@ -13894,7 +12650,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 1001
ProcessUserIDKey = attribute.Key("process.user.id")
@@ -13905,7 +12661,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "root"
ProcessUserNameKey = attribute.Key("process.user.name")
@@ -13915,7 +12671,7 @@ const (
//
// Type: int
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: 12
// Note: The process ID within a PID namespace. This is not necessarily unique
@@ -13929,7 +12685,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "/root"
ProcessWorkingDirectoryKey = attribute.Key("process.working_directory")
@@ -14178,26 +12934,26 @@ func ProcessWorkingDirectory(val string) attribute.KeyValue {
// Enum values for process.context_switch.type
var (
// voluntary
- // Stability: development
+ // Stability: release_candidate
ProcessContextSwitchTypeVoluntary = ProcessContextSwitchTypeKey.String("voluntary")
// involuntary
- // Stability: development
+ // Stability: release_candidate
ProcessContextSwitchTypeInvoluntary = ProcessContextSwitchTypeKey.String("involuntary")
)
// Enum values for process.state
var (
// running
- // Stability: development
+ // Stability: release_candidate
ProcessStateRunning = ProcessStateKey.String("running")
// sleeping
- // Stability: development
+ // Stability: release_candidate
ProcessStateSleeping = ProcessStateKey.String("sleeping")
// stopped
- // Stability: development
+ // Stability: release_candidate
ProcessStateStopped = ProcessStateKey.String("stopped")
// defunct
- // Stability: development
+ // Stability: release_candidate
ProcessStateDefunct = ProcessStateKey.String("defunct")
)
@@ -14293,6 +13049,12 @@ var (
//
// [Rust]: https://wikipedia.org/wiki/Rust_(programming_language)
ProfileFrameTypeRust = ProfileFrameTypeKey.String("rust")
+ // [LuaJIT]
+ //
+ // Stability: development
+ //
+ // [LuaJIT]: https://en.wikipedia.org/wiki/LuaJIT
+ ProfileFrameTypeLuajit = ProfileFrameTypeKey.String("luajit")
)
// Namespace: rpc
@@ -14642,7 +13404,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Alpha
//
// Examples: "critical", "high", "medium", "low"
// Note: Application developers are encouraged to set `service.criticality` to
@@ -14840,21 +13602,21 @@ var (
// Service is business-critical; downtime directly impacts revenue, user
// experience, or core functionality.
//
- // Stability: development
+ // Stability: alpha
ServiceCriticalityCritical = ServiceCriticalityKey.String("critical")
// Service is important but has degradation tolerance or fallback mechanisms.
//
- // Stability: development
+ // Stability: alpha
ServiceCriticalityHigh = ServiceCriticalityKey.String("high")
// Service provides supplementary functionality; degradation has limited user
// impact.
//
- // Stability: development
+ // Stability: alpha
ServiceCriticalityMedium = ServiceCriticalityKey.String("medium")
// Service is non-essential to core operations; used for background tasks or
// internal tools.
//
- // Stability: development
+ // Stability: alpha
ServiceCriticalityLow = ServiceCriticalityKey.String("low")
)
@@ -15095,7 +13857,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "minor"
SystemPagingFaultTypeKey = attribute.Key("system.paging.fault.type")
@@ -15216,10 +13978,10 @@ var (
// Enum values for system.paging.fault.type
var (
// major
- // Stability: development
+ // Stability: release_candidate
SystemPagingFaultTypeMajor = SystemPagingFaultTypeKey.String("major")
// minor
- // Stability: development
+ // Stability: release_candidate
SystemPagingFaultTypeMinor = SystemPagingFaultTypeKey.String("minor")
)
@@ -15350,6 +14112,9 @@ var (
// java
// Stability: stable
TelemetrySDKLanguageJava = TelemetrySDKLanguageKey.String("java")
+ // kotlin
+ // Stability: stable
+ TelemetrySDKLanguageKotlin = TelemetrySDKLanguageKey.String("kotlin")
// nodejs
// Stability: stable
TelemetrySDKLanguageNodejs = TelemetrySDKLanguageKey.String("nodejs")
@@ -16191,8 +14956,9 @@ const (
// replaced by the
// value `REDACTED`:
//
- // - [`AWSAccessKeyId`]
- // - [`Signature`]
+ // - [`X-Amz-Signature`]
+ // - [`X-Amz-Credential`]
+ // - [`X-Amz-Security-Token`]
// - [`sig`]
// - [`X-Goog-Signature`]
//
@@ -16215,8 +14981,9 @@ const (
// `https://www.example.com/path?color=blue&sig=REDACTED`.
//
// [RFC3986]: https://www.rfc-editor.org/rfc/rfc3986
- // [`AWSAccessKeyId`]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAuthentication.html#RESTAuthenticationQueryStringAuth
- // [`Signature`]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAuthentication.html#RESTAuthenticationQueryStringAuth
+ // [`X-Amz-Signature`]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-authentication-methods.html
+ // [`X-Amz-Credential`]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-authentication-methods.html
+ // [`X-Amz-Security-Token`]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-authentication-methods.html
// [`sig`]: https://learn.microsoft.com/azure/storage/common/storage-sas-overview#sas-token
// [`X-Goog-Signature`]: https://cloud.google.com/storage/docs/access-control/signed-urls
URLFullKey = attribute.Key("url.full")
@@ -16278,8 +15045,9 @@ const (
// Query string values for the following keys SHOULD be redacted by default and
// replaced by the value `REDACTED`:
//
- // - [`AWSAccessKeyId`]
- // - [`Signature`]
+ // - [`X-Amz-Signature`]
+ // - [`X-Amz-Credential`]
+ // - [`X-Amz-Security-Token`]
// - [`sig`]
// - [`X-Goog-Signature`]
//
@@ -16301,8 +15069,9 @@ const (
// `q=OpenTelemetry&sig=REDACTED`.
//
// [URI query]: https://www.rfc-editor.org/rfc/rfc3986#section-3.4
- // [`AWSAccessKeyId`]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAuthentication.html#RESTAuthenticationQueryStringAuth
- // [`Signature`]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAuthentication.html#RESTAuthenticationQueryStringAuth
+ // [`X-Amz-Signature`]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-authentication-methods.html
+ // [`X-Amz-Credential`]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-authentication-methods.html
+ // [`X-Amz-Security-Token`]: https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv-authentication-methods.html
// [`sig`]: https://learn.microsoft.com/azure/storage/common/storage-sas-overview#sas-token
// [`X-Goog-Signature`]: https://cloud.google.com/storage/docs/access-control/signed-urls
URLQueryKey = attribute.Key("url.query")
@@ -16752,7 +15521,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "123"
VCSChangeIDKey = attribute.Key("vcs.change.id")
@@ -16763,7 +15532,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "open", "closed", "merged"
VCSChangeStateKey = attribute.Key("vcs.change.state")
@@ -16775,7 +15544,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "Fixes broken thing", "feat: add my new feature", "[chore] update
// dependency"
@@ -16787,7 +15556,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "added", "removed"
VCSLineChangeTypeKey = attribute.Key("vcs.line_change.type")
@@ -16798,7 +15567,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "my-org", "myteam", "business-unit"
VCSOwnerNameKey = attribute.Key("vcs.owner.name")
@@ -16809,7 +15578,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "github", "gitlab", "gitea", "bitbucket"
VCSProviderNameKey = attribute.Key("vcs.provider.name")
@@ -16820,7 +15589,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "my-feature-branch", "tag-1-test"
// Note: `base` refers to the starting point of a change. For example, `main`
@@ -16837,7 +15606,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "9d59409acf479dfa0df1aa568182e43e43df8bbe28d60fcf2bc52e30068802cc",
// "main", "123", "HEAD"
@@ -16869,7 +15638,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "branch", "tag"
// Note: `base` refers to the starting point of a change. For example, `main`
@@ -16885,7 +15654,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "my-feature-branch", "tag-1-test"
// Note: `head` refers to where you are right now; the current reference at a
@@ -16901,7 +15670,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "9d59409acf479dfa0df1aa568182e43e43df8bbe28d60fcf2bc52e30068802cc",
// "main", "123", "HEAD"
@@ -16931,7 +15700,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "branch", "tag"
// Note: `head` refers to where you are right now; the current reference at a
@@ -16945,7 +15714,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "branch", "tag"
//
@@ -16959,7 +15728,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "semantic-conventions", "my-cool-repo"
// Note: Due to it only being the name, it can clash with forks of the same
@@ -16974,7 +15743,7 @@ const (
//
// Type: string
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples:
// "https://github.com/opentelemetry/open-telemetry-collector-contrib",
@@ -16991,7 +15760,7 @@ const (
//
// Type: Enum
// RequirementLevel: Recommended
- // Stability: Development
+ // Stability: Release_Candidate
//
// Examples: "ahead", "behind"
VCSRevisionDeltaDirectionKey = attribute.Key("vcs.revision_delta.direction")
@@ -17082,53 +15851,53 @@ var (
// Open means the change is currently active and under review. It hasn't been
// merged into the target branch yet, and it's still possible to make changes or
// add comments.
- // Stability: development
+ // Stability: release_candidate
VCSChangeStateOpen = VCSChangeStateKey.String("open")
// WIP (work-in-progress, draft) means the change is still in progress and not
// yet ready for a full review. It might still undergo significant changes.
- // Stability: development
+ // Stability: release_candidate
VCSChangeStateWip = VCSChangeStateKey.String("wip")
// Closed means the merge request has been closed without merging. This can
// happen for various reasons, such as the changes being deemed unnecessary, the
// issue being resolved in another way, or the author deciding to withdraw the
// request.
- // Stability: development
+ // Stability: release_candidate
VCSChangeStateClosed = VCSChangeStateKey.String("closed")
// Merged indicates that the change has been successfully integrated into the
// target codebase.
- // Stability: development
+ // Stability: release_candidate
VCSChangeStateMerged = VCSChangeStateKey.String("merged")
)
// Enum values for vcs.line_change.type
var (
// How many lines were added.
- // Stability: development
+ // Stability: release_candidate
VCSLineChangeTypeAdded = VCSLineChangeTypeKey.String("added")
// How many lines were removed.
- // Stability: development
+ // Stability: release_candidate
VCSLineChangeTypeRemoved = VCSLineChangeTypeKey.String("removed")
)
// Enum values for vcs.provider.name
var (
// [GitHub]
- // Stability: development
+ // Stability: release_candidate
//
// [GitHub]: https://github.com
VCSProviderNameGithub = VCSProviderNameKey.String("github")
// [GitLab]
- // Stability: development
+ // Stability: release_candidate
//
// [GitLab]: https://gitlab.com
VCSProviderNameGitlab = VCSProviderNameKey.String("gitlab")
// [Gitea]
- // Stability: development
+ // Stability: release_candidate
//
// [Gitea]: https://gitea.io
VCSProviderNameGitea = VCSProviderNameKey.String("gitea")
// [Bitbucket]
- // Stability: development
+ // Stability: release_candidate
//
// [Bitbucket]: https://bitbucket.org
VCSProviderNameBitbucket = VCSProviderNameKey.String("bitbucket")
@@ -17137,12 +15906,12 @@ var (
// Enum values for vcs.ref.base.type
var (
// [branch]
- // Stability: development
+ // Stability: release_candidate
//
// [branch]: https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbranchabranch
VCSRefBaseTypeBranch = VCSRefBaseTypeKey.String("branch")
// [tag]
- // Stability: development
+ // Stability: release_candidate
//
// [tag]: https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddeftagatag
VCSRefBaseTypeTag = VCSRefBaseTypeKey.String("tag")
@@ -17151,12 +15920,12 @@ var (
// Enum values for vcs.ref.head.type
var (
// [branch]
- // Stability: development
+ // Stability: release_candidate
//
// [branch]: https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbranchabranch
VCSRefHeadTypeBranch = VCSRefHeadTypeKey.String("branch")
// [tag]
- // Stability: development
+ // Stability: release_candidate
//
// [tag]: https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddeftagatag
VCSRefHeadTypeTag = VCSRefHeadTypeKey.String("tag")
@@ -17165,12 +15934,12 @@ var (
// Enum values for vcs.ref.type
var (
// [branch]
- // Stability: development
+ // Stability: release_candidate
//
// [branch]: https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddefbranchabranch
VCSRefTypeBranch = VCSRefTypeKey.String("branch")
// [tag]
- // Stability: development
+ // Stability: release_candidate
//
// [tag]: https://git-scm.com/docs/gitglossary#Documentation/gitglossary.txt-aiddeftagatag
VCSRefTypeTag = VCSRefTypeKey.String("tag")
@@ -17179,10 +15948,10 @@ var (
// Enum values for vcs.revision_delta.direction
var (
// How many revisions the change is behind the target ref.
- // Stability: development
+ // Stability: release_candidate
VCSRevisionDeltaDirectionBehind = VCSRevisionDeltaDirectionKey.String("behind")
// How many revisions the change is ahead of the target ref.
- // Stability: development
+ // Stability: release_candidate
VCSRevisionDeltaDirectionAhead = VCSRevisionDeltaDirectionKey.String("ahead")
)
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/doc.go b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/doc.go
similarity index 83%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.41.0/doc.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.43.0/doc.go
index a45d424d8..aadce15c0 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/doc.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/doc.go
@@ -6,6 +6,6 @@
// Package semconv implements OpenTelemetry semantic conventions.
//
// OpenTelemetry semantic conventions are agreed standardized naming
-// patterns for OpenTelemetry things. This package represents the v1.41.0
+// patterns for OpenTelemetry things. This package represents the v1.43.0
// version of the OpenTelemetry semantic conventions.
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.41.0"
+package semconv
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/error_type.go b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/error_type.go
similarity index 96%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.41.0/error_type.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.43.0/error_type.go
index 0b13f0de8..5d8eff222 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/error_type.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/error_type.go
@@ -3,7 +3,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.41.0"
+package semconv
import (
"errors"
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/exception.go b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/exception.go
similarity index 80%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.41.0/exception.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.43.0/exception.go
index 5f0151aff..6c9b05adb 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/exception.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/exception.go
@@ -3,7 +3,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.41.0"
+package semconv
const (
// ExceptionEventName is the name of the Span event representing an exception.
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/otelconv/metric.go
similarity index 93%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.43.0/otelconv/metric.go
index d50e19849..9eaf0fd9a 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/otelconv/metric.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/otelconv/metric.go
@@ -9,16 +9,11 @@ package otelconv
import (
"context"
- "sync"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/metric"
"go.opentelemetry.io/otel/metric/noop"
-)
-
-var (
- addOptPool = &sync.Pool{New: func() any { return &[]metric.AddOption{} }}
- recOptPool = &sync.Pool{New: func() any { return &[]metric.RecordOption{} }}
+ "go.opentelemetry.io/otel/semconv/internal/metricpool"
)
// ErrorTypeAttr is an attribute conforming to the error.type semantic
@@ -192,6 +187,12 @@ func (SDKExporterLogExported) Description() string {
// non-rejected log records count as success.
// If no rejection reason is available, `rejected` SHOULD be used as value for
// `error.type`.
+// If the exporter retries failed export attempts, the export operation is
+// considered finished only after the final attempt has concluded.
+// Each log record MUST be counted exactly once per export operation:
+// intermediate failed attempts that are followed by a retry MUST NOT increment
+// the counter,
+// and `error.type` reflects the cause of the final attempt.
func (m SDKExporterLogExported) Add(
ctx context.Context,
incr int64,
@@ -205,12 +206,8 @@ func (m SDKExporterLogExported) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -231,6 +228,12 @@ func (m SDKExporterLogExported) Add(
// non-rejected log records count as success.
// If no rejection reason is available, `rejected` SHOULD be used as value for
// `error.type`.
+// If the exporter retries failed export attempts, the export operation is
+// considered finished only after the final attempt has concluded.
+// Each log record MUST be counted exactly once per export operation:
+// intermediate failed attempts that are followed by a retry MUST NOT increment
+// the counter,
+// and `error.type` reflects the cause of the final attempt.
func (m SDKExporterLogExported) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64Counter.Enabled(ctx) {
return
@@ -240,12 +243,8 @@ func (m SDKExporterLogExported) AddSet(ctx context.Context, incr int64, set attr
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -442,8 +441,10 @@ func (SDKExporterLogInflight) Description() string {
//
// All additional attrs passed are included in the recorded value.
//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
+// Log records are counted as inflight from when they are passed to the exporter
+// until the export operation has concluded.
+// If the exporter retries failed export attempts, log records remain inflight
+// across all retry attempts and any backoff between them.
func (m SDKExporterLogInflight) Add(
ctx context.Context,
incr int64,
@@ -457,12 +458,8 @@ func (m SDKExporterLogInflight) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -476,8 +473,10 @@ func (m SDKExporterLogInflight) Add(
// AddSet adds incr to the existing count for set.
//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
+// Log records are counted as inflight from when they are passed to the exporter
+// until the export operation has concluded.
+// If the exporter retries failed export attempts, log records remain inflight
+// across all retry attempts and any backoff between them.
func (m SDKExporterLogInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64UpDownCounter.Enabled(ctx) {
return
@@ -487,12 +486,8 @@ func (m SDKExporterLogInflight) AddSet(ctx context.Context, incr int64, set attr
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64UpDownCounter.Add(ctx, incr, *o...)
@@ -683,6 +678,12 @@ func (SDKExporterMetricDataPointExported) Description() string {
// non-rejected data points count as success.
// If no rejection reason is available, `rejected` SHOULD be used as value for
// `error.type`.
+// If the exporter retries failed export attempts, the export operation is
+// considered finished only after the final attempt has concluded.
+// Each metric data point MUST be counted exactly once per export operation:
+// intermediate failed attempts that are followed by a retry MUST NOT increment
+// the counter,
+// and `error.type` reflects the cause of the final attempt.
func (m SDKExporterMetricDataPointExported) Add(
ctx context.Context,
incr int64,
@@ -696,12 +697,8 @@ func (m SDKExporterMetricDataPointExported) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -722,6 +719,12 @@ func (m SDKExporterMetricDataPointExported) Add(
// non-rejected data points count as success.
// If no rejection reason is available, `rejected` SHOULD be used as value for
// `error.type`.
+// If the exporter retries failed export attempts, the export operation is
+// considered finished only after the final attempt has concluded.
+// Each metric data point MUST be counted exactly once per export operation:
+// intermediate failed attempts that are followed by a retry MUST NOT increment
+// the counter,
+// and `error.type` reflects the cause of the final attempt.
func (m SDKExporterMetricDataPointExported) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64Counter.Enabled(ctx) {
return
@@ -731,12 +734,8 @@ func (m SDKExporterMetricDataPointExported) AddSet(ctx context.Context, incr int
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -935,8 +934,10 @@ func (SDKExporterMetricDataPointInflight) Description() string {
//
// All additional attrs passed are included in the recorded value.
//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
+// Metric data points are counted as inflight from when they are passed to the
+// exporter until the export operation has concluded.
+// If the exporter retries failed export attempts, metric data points remain
+// inflight across all retry attempts and any backoff between them.
func (m SDKExporterMetricDataPointInflight) Add(
ctx context.Context,
incr int64,
@@ -950,12 +951,8 @@ func (m SDKExporterMetricDataPointInflight) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -969,8 +966,10 @@ func (m SDKExporterMetricDataPointInflight) Add(
// AddSet adds incr to the existing count for set.
//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
+// Metric data points are counted as inflight from when they are passed to the
+// exporter until the export operation has concluded.
+// If the exporter retries failed export attempts, metric data points remain
+// inflight across all retry attempts and any backoff between them.
func (m SDKExporterMetricDataPointInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64UpDownCounter.Enabled(ctx) {
return
@@ -980,12 +979,8 @@ func (m SDKExporterMetricDataPointInflight) AddSet(ctx context.Context, incr int
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64UpDownCounter.Add(ctx, incr, *o...)
@@ -1175,6 +1170,11 @@ func (SDKExporterOperationDuration) Description() string {
// successful
// operations, `error.type` MUST NOT be set. For unsuccessful export operations,
// `error.type` MUST contain a relevant failure cause.
+// If the exporter retries failed export attempts, exactly one observation MUST
+// be recorded per export operation,
+// covering the wall-clock duration from the start of the first attempt through
+// the conclusion of the final attempt (including any backoff between attempts).
+// `error.type` reflects the cause of the final attempt.
//
// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1
// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success
@@ -1191,12 +1191,8 @@ func (m SDKExporterOperationDuration) Record(
return
}
- o := recOptPool.Get().(*[]metric.RecordOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- recOptPool.Put(o)
- }()
+ o := metricpool.RecordOptions()
+ defer metricpool.PutRecordOptions(o)
*o = append(
*o,
@@ -1216,6 +1212,11 @@ func (m SDKExporterOperationDuration) Record(
// successful
// operations, `error.type` MUST NOT be set. For unsuccessful export operations,
// `error.type` MUST contain a relevant failure cause.
+// If the exporter retries failed export attempts, exactly one observation MUST
+// be recorded per export operation,
+// covering the wall-clock duration from the start of the first attempt through
+// the conclusion of the final attempt (including any backoff between attempts).
+// `error.type` reflects the cause of the final attempt.
//
// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1
// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success
@@ -1228,12 +1229,8 @@ func (m SDKExporterOperationDuration) RecordSet(ctx context.Context, val float64
return
}
- o := recOptPool.Get().(*[]metric.RecordOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- recOptPool.Put(o)
- }()
+ o := metricpool.RecordOptions()
+ defer metricpool.PutRecordOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Float64Histogram.Record(ctx, val, *o...)
@@ -1357,6 +1354,11 @@ func (SDKExporterSpanExported) Description() string {
// success.
// If no rejection reason is available, `rejected` SHOULD be used as value for
// `error.type`.
+// If the exporter retries failed export attempts, the export operation is
+// considered finished only after the final attempt has concluded.
+// Each span MUST be counted exactly once per export operation: intermediate
+// failed attempts that are followed by a retry MUST NOT increment the counter,
+// and `error.type` reflects the cause of the final attempt.
func (m SDKExporterSpanExported) Add(
ctx context.Context,
incr int64,
@@ -1370,12 +1372,8 @@ func (m SDKExporterSpanExported) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -1396,6 +1394,11 @@ func (m SDKExporterSpanExported) Add(
// success.
// If no rejection reason is available, `rejected` SHOULD be used as value for
// `error.type`.
+// If the exporter retries failed export attempts, the export operation is
+// considered finished only after the final attempt has concluded.
+// Each span MUST be counted exactly once per export operation: intermediate
+// failed attempts that are followed by a retry MUST NOT increment the counter,
+// and `error.type` reflects the cause of the final attempt.
func (m SDKExporterSpanExported) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64Counter.Enabled(ctx) {
return
@@ -1405,12 +1408,8 @@ func (m SDKExporterSpanExported) AddSet(ctx context.Context, incr int64, set att
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -1607,8 +1606,10 @@ func (SDKExporterSpanInflight) Description() string {
//
// All additional attrs passed are included in the recorded value.
//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
+// Spans are counted as inflight from when they are passed to the exporter until
+// the export operation has concluded.
+// If the exporter retries failed export attempts, spans remain inflight across
+// all retry attempts and any backoff between them.
func (m SDKExporterSpanInflight) Add(
ctx context.Context,
incr int64,
@@ -1622,12 +1623,8 @@ func (m SDKExporterSpanInflight) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -1641,8 +1638,10 @@ func (m SDKExporterSpanInflight) Add(
// AddSet adds incr to the existing count for set.
//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
+// Spans are counted as inflight from when they are passed to the exporter until
+// the export operation has concluded.
+// If the exporter retries failed export attempts, spans remain inflight across
+// all retry attempts and any backoff between them.
func (m SDKExporterSpanInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64UpDownCounter.Enabled(ctx) {
return
@@ -1652,12 +1651,8 @@ func (m SDKExporterSpanInflight) AddSet(ctx context.Context, incr int64, set att
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64UpDownCounter.Add(ctx, incr, *o...)
@@ -1846,12 +1841,8 @@ func (m SDKLogCreated) Add(ctx context.Context, incr int64, attrs ...attribute.K
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributes(attrs...))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -1867,12 +1858,8 @@ func (m SDKLogCreated) AddSet(ctx context.Context, incr int64, set attribute.Set
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -2018,12 +2005,8 @@ func (m SDKMetricReaderCollectionDuration) Record(
return
}
- o := recOptPool.Get().(*[]metric.RecordOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- recOptPool.Put(o)
- }()
+ o := metricpool.RecordOptions()
+ defer metricpool.PutRecordOptions(o)
*o = append(
*o,
@@ -2051,12 +2034,8 @@ func (m SDKMetricReaderCollectionDuration) RecordSet(ctx context.Context, val fl
return
}
- o := recOptPool.Get().(*[]metric.RecordOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- recOptPool.Put(o)
- }()
+ o := metricpool.RecordOptions()
+ defer metricpool.PutRecordOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Float64Histogram.Record(ctx, val, *o...)
@@ -2148,6 +2127,11 @@ func (SDKProcessorLogProcessed) Description() string {
//
// For successful processing, `error.type` MUST NOT be set. For failed
// processing, `error.type` MUST contain the failure cause.
+// SDK Batching Log Record Processors MUST use `queue_full` as the value of
+// `error.type` for log records dropped due to a full queue.
+// SDK Log Record Processors MUST use `already_shutdown` as the value of
+// `error.type` for log records dropped because the processor has already been
+// shut down.
// For the SDK Simple and Batching Log Record Processor a log record is
// considered to be processed already when it has been submitted to the exporter,
// not when the corresponding export call has finished.
@@ -2164,12 +2148,8 @@ func (m SDKProcessorLogProcessed) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -2185,6 +2165,11 @@ func (m SDKProcessorLogProcessed) Add(
//
// For successful processing, `error.type` MUST NOT be set. For failed
// processing, `error.type` MUST contain the failure cause.
+// SDK Batching Log Record Processors MUST use `queue_full` as the value of
+// `error.type` for log records dropped due to a full queue.
+// SDK Log Record Processors MUST use `already_shutdown` as the value of
+// `error.type` for log records dropped because the processor has already been
+// shut down.
// For the SDK Simple and Batching Log Record Processor a log record is
// considered to be processed already when it has been submitted to the exporter,
// not when the corresponding export call has finished.
@@ -2197,12 +2182,8 @@ func (m SDKProcessorLogProcessed) AddSet(ctx context.Context, incr int64, set at
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -2210,8 +2191,6 @@ func (m SDKProcessorLogProcessed) AddSet(ctx context.Context, incr int64, set at
// AttrErrorType returns an optional attribute for the "error.type" semantic
// convention. It represents a low-cardinality description of the failure reason.
-// SDK Batching Log Record Processors MUST use `queue_full` for log records
-// dropped due to a full queue.
func (SDKProcessorLogProcessed) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
return attribute.String("error.type", string(val))
}
@@ -2292,8 +2271,6 @@ func (SDKProcessorLogProcessedObservable) Description() string {
// AttrErrorType returns an optional attribute for the "error.type" semantic
// convention. It represents a low-cardinality description of the failure reason.
-// SDK Batching Log Record Processors MUST use `queue_full` for log records
-// dropped due to a full queue.
func (SDKProcessorLogProcessedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
return attribute.String("error.type", string(val))
}
@@ -2525,6 +2502,10 @@ func (SDKProcessorSpanProcessed) Description() string {
//
// For successful processing, `error.type` MUST NOT be set. For failed
// processing, `error.type` MUST contain the failure cause.
+// SDK Batching Span Processors MUST use `queue_full` as the value of
+// `error.type` for spans dropped due to a full queue.
+// SDK Span Processors MUST use `already_shutdown` as the value of `error.type`
+// for spans dropped because the processor has already been shut down.
// For the SDK Simple and Batching Span Processor a span is considered to be
// processed already when it has been submitted to the exporter, not when the
// corresponding export call has finished.
@@ -2541,12 +2522,8 @@ func (m SDKProcessorSpanProcessed) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -2562,6 +2539,10 @@ func (m SDKProcessorSpanProcessed) Add(
//
// For successful processing, `error.type` MUST NOT be set. For failed
// processing, `error.type` MUST contain the failure cause.
+// SDK Batching Span Processors MUST use `queue_full` as the value of
+// `error.type` for spans dropped due to a full queue.
+// SDK Span Processors MUST use `already_shutdown` as the value of `error.type`
+// for spans dropped because the processor has already been shut down.
// For the SDK Simple and Batching Span Processor a span is considered to be
// processed already when it has been submitted to the exporter, not when the
// corresponding export call has finished.
@@ -2574,12 +2555,8 @@ func (m SDKProcessorSpanProcessed) AddSet(ctx context.Context, incr int64, set a
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
@@ -2587,8 +2564,6 @@ func (m SDKProcessorSpanProcessed) AddSet(ctx context.Context, incr int64, set a
// AttrErrorType returns an optional attribute for the "error.type" semantic
// convention. It represents a low-cardinality description of the failure reason.
-// SDK Batching Span Processors MUST use `queue_full` for spans dropped due to a
-// full queue.
func (SDKProcessorSpanProcessed) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
return attribute.String("error.type", string(val))
}
@@ -2669,8 +2644,6 @@ func (SDKProcessorSpanProcessedObservable) Description() string {
// AttrErrorType returns an optional attribute for the "error.type" semantic
// convention. It represents a low-cardinality description of the failure reason.
-// SDK Batching Span Processors MUST use `queue_full` for spans dropped due to a
-// full queue.
func (SDKProcessorSpanProcessedObservable) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
return attribute.String("error.type", string(val))
}
@@ -2899,6 +2872,9 @@ func (SDKSpanLive) Description() string {
// Add adds incr to the existing count for attrs.
//
// All additional attrs passed are included in the recorded value.
+//
+// Non-recording spans are not counted, hence `otel.span.sampling_result` can
+// only take values `RECORD_ONLY` and `RECORD_AND_SAMPLE`, not `DROP`.
func (m SDKSpanLive) Add(
ctx context.Context,
incr int64,
@@ -2912,12 +2888,8 @@ func (m SDKSpanLive) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -2930,6 +2902,9 @@ func (m SDKSpanLive) Add(
}
// AddSet adds incr to the existing count for set.
+//
+// Non-recording spans are not counted, hence `otel.span.sampling_result` can
+// only take values `RECORD_ONLY` and `RECORD_AND_SAMPLE`, not `DROP`.
func (m SDKSpanLive) AddSet(ctx context.Context, incr int64, set attribute.Set) {
if !m.Int64UpDownCounter.Enabled(ctx) {
return
@@ -2939,12 +2914,8 @@ func (m SDKSpanLive) AddSet(ctx context.Context, incr int64, set attribute.Set)
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64UpDownCounter.Add(ctx, incr, *o...)
@@ -3100,12 +3071,8 @@ func (m SDKSpanStarted) Add(
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(
*o,
@@ -3130,12 +3097,8 @@ func (m SDKSpanStarted) AddSet(ctx context.Context, incr int64, set attribute.Se
return
}
- o := addOptPool.Get().(*[]metric.AddOption)
- defer func() {
- clear(*o)
- *o = (*o)[:0]
- addOptPool.Put(o)
- }()
+ o := metricpool.AddOptions()
+ defer metricpool.PutAddOptions(o)
*o = append(*o, metric.WithAttributeSet(set))
m.Int64Counter.Add(ctx, incr, *o...)
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/schema.go b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/schema.go
similarity index 75%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.41.0/schema.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.43.0/schema.go
index 24948a48f..ce5f5f5c5 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.41.0/schema.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.43.0/schema.go
@@ -3,9 +3,9 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package semconv // import "go.opentelemetry.io/otel/semconv/v1.41.0"
+package semconv
// SchemaURL is the schema URL that matches the version of the semantic conventions
// that this package defines. Semconv packages starting from v1.4.0 must declare
// non-empty schema URL in the form https://opentelemetry.io/schemas/
-const SchemaURL = "https://opentelemetry.io/schemas/1.41.0"
+const SchemaURL = "https://opentelemetry.io/schemas/1.43.0"
diff --git a/vendor/go.opentelemetry.io/otel/trace.go b/vendor/go.opentelemetry.io/otel/trace.go
index 6836c6547..9c1567a2e 100644
--- a/vendor/go.opentelemetry.io/otel/trace.go
+++ b/vendor/go.opentelemetry.io/otel/trace.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
import (
"go.opentelemetry.io/otel/internal/global"
diff --git a/vendor/go.opentelemetry.io/otel/trace/auto.go b/vendor/go.opentelemetry.io/otel/trace/auto.go
index a75cf047d..17cf898cd 100644
--- a/vendor/go.opentelemetry.io/otel/trace/auto.go
+++ b/vendor/go.opentelemetry.io/otel/trace/auto.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"context"
@@ -20,7 +20,7 @@ import (
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
- semconv "go.opentelemetry.io/otel/semconv/v1.41.0"
+ semconv "go.opentelemetry.io/otel/semconv/v1.43.0"
"go.opentelemetry.io/otel/trace/embedded"
"go.opentelemetry.io/otel/trace/internal/telemetry"
)
@@ -358,6 +358,16 @@ func convAttrValue(value attribute.Value) telemetry.Value {
out = append(out, convAttrValue(v))
}
return telemetry.SliceValue(out...)
+ case attribute.MAP:
+ kvs := value.AsMap()
+ out := make([]telemetry.Attr, 0, len(kvs))
+ for _, kv := range kvs {
+ out = append(out, telemetry.Attr{
+ Key: string(kv.Key),
+ Value: convAttrValue(kv.Value),
+ })
+ }
+ return telemetry.MapValue(out...)
}
return telemetry.Value{}
}
diff --git a/vendor/go.opentelemetry.io/otel/trace/config.go b/vendor/go.opentelemetry.io/otel/trace/config.go
index 4cedba5ac..862ecc898 100644
--- a/vendor/go.opentelemetry.io/otel/trace/config.go
+++ b/vendor/go.opentelemetry.io/otel/trace/config.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"slices"
diff --git a/vendor/go.opentelemetry.io/otel/trace/context.go b/vendor/go.opentelemetry.io/otel/trace/context.go
index 8c45a7107..89927eda6 100644
--- a/vendor/go.opentelemetry.io/otel/trace/context.go
+++ b/vendor/go.opentelemetry.io/otel/trace/context.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import "context"
diff --git a/vendor/go.opentelemetry.io/otel/trace/doc.go b/vendor/go.opentelemetry.io/otel/trace/doc.go
index cdbf41d6d..57de8f348 100644
--- a/vendor/go.opentelemetry.io/otel/trace/doc.go
+++ b/vendor/go.opentelemetry.io/otel/trace/doc.go
@@ -116,4 +116,4 @@ It is strongly recommended that authors only embed
That implementation is the only one OpenTelemetry authors can guarantee will
fully implement all the API interfaces when a user updates their API.
*/
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
diff --git a/vendor/go.opentelemetry.io/otel/trace/embedded/embedded.go b/vendor/go.opentelemetry.io/otel/trace/embedded/embedded.go
index 3e359a00b..59d8a510b 100644
--- a/vendor/go.opentelemetry.io/otel/trace/embedded/embedded.go
+++ b/vendor/go.opentelemetry.io/otel/trace/embedded/embedded.go
@@ -11,7 +11,7 @@
// the API package).
//
// [OpenTelemetry trace API]: https://pkg.go.dev/go.opentelemetry.io/otel/trace
-package embedded // import "go.opentelemetry.io/otel/trace/embedded"
+package embedded
// TracerProvider is embedded in
// [go.opentelemetry.io/otel/trace.TracerProvider].
diff --git a/vendor/go.opentelemetry.io/otel/trace/hex.go b/vendor/go.opentelemetry.io/otel/trace/hex.go
index 1cbef1d4b..5f156b0dc 100644
--- a/vendor/go.opentelemetry.io/otel/trace/hex.go
+++ b/vendor/go.opentelemetry.io/otel/trace/hex.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
const (
// hexLU is a hex lookup table of the 16 lowercase hex digits.
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/attr.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/attr.go
index ff0f6eac6..9503318eb 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/attr.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/attr.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
// Attr is a key-value pair.
type Attr struct {
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/doc.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/doc.go
index 5debe90bb..949e2165c 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/doc.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/doc.go
@@ -5,4 +5,4 @@
Package telemetry provides a lightweight representations of OpenTelemetry
telemetry that is compatible with the OTLP JSON protobuf encoding.
*/
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/id.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/id.go
index bea56f2e7..3a6d6b87a 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/id.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/id.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"encoding/hex"
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/number.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/number.go
index f5e3a8cec..29e629d66 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/number.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/number.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"encoding/json"
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/resource.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/resource.go
index 1798a702d..cecad8bae 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/resource.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/resource.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"bytes"
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/scope.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/scope.go
index c2b4c635b..b6f2e28d4 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/scope.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/scope.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"bytes"
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/span.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/span.go
index 61c7819a2..0da6e5fd6 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/span.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/span.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"bytes"
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/status.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/status.go
index 1039bf40c..5dac1b2cb 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/status.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/status.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
// StatusCode is the status of a Span.
//
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/traces.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/traces.go
index e5f10767c..44197b808 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/traces.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/traces.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"bytes"
diff --git a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/value.go b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/value.go
index cb7927b81..9d2d68063 100644
--- a/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/value.go
+++ b/vendor/go.opentelemetry.io/otel/trace/internal/telemetry/value.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package telemetry // import "go.opentelemetry.io/otel/trace/internal/telemetry"
+package telemetry
import (
"bytes"
diff --git a/vendor/go.opentelemetry.io/otel/trace/nonrecording.go b/vendor/go.opentelemetry.io/otel/trace/nonrecording.go
index c00221e7b..d672f03c2 100644
--- a/vendor/go.opentelemetry.io/otel/trace/nonrecording.go
+++ b/vendor/go.opentelemetry.io/otel/trace/nonrecording.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
// nonRecordingSpan is a minimal implementation of a Span that wraps a
// SpanContext. It performs no operations other than to return the wrapped
diff --git a/vendor/go.opentelemetry.io/otel/trace/noop.go b/vendor/go.opentelemetry.io/otel/trace/noop.go
index 400fab123..b954251b2 100644
--- a/vendor/go.opentelemetry.io/otel/trace/noop.go
+++ b/vendor/go.opentelemetry.io/otel/trace/noop.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/trace/noop/noop.go b/vendor/go.opentelemetry.io/otel/trace/noop/noop.go
index 689d220df..4f8190e41 100644
--- a/vendor/go.opentelemetry.io/otel/trace/noop/noop.go
+++ b/vendor/go.opentelemetry.io/otel/trace/noop/noop.go
@@ -10,7 +10,7 @@
// This implementation can be embedded in other implementations of the
// OpenTelemetry trace API. Doing so will mean the implementation defaults to
// no operation for methods it does not implement.
-package noop // import "go.opentelemetry.io/otel/trace/noop"
+package noop
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/trace/provider.go b/vendor/go.opentelemetry.io/otel/trace/provider.go
index ef85cb70c..891cc0b8c 100644
--- a/vendor/go.opentelemetry.io/otel/trace/provider.go
+++ b/vendor/go.opentelemetry.io/otel/trace/provider.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import "go.opentelemetry.io/otel/trace/embedded"
diff --git a/vendor/go.opentelemetry.io/otel/trace/span.go b/vendor/go.opentelemetry.io/otel/trace/span.go
index d01e79366..603b2c146 100644
--- a/vendor/go.opentelemetry.io/otel/trace/span.go
+++ b/vendor/go.opentelemetry.io/otel/trace/span.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/trace/trace.go b/vendor/go.opentelemetry.io/otel/trace/trace.go
index e3d103c4b..c4c383819 100644
--- a/vendor/go.opentelemetry.io/otel/trace/trace.go
+++ b/vendor/go.opentelemetry.io/otel/trace/trace.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"encoding/json"
diff --git a/vendor/go.opentelemetry.io/otel/trace/tracer.go b/vendor/go.opentelemetry.io/otel/trace/tracer.go
index 77952d2a0..7e6e5ee93 100644
--- a/vendor/go.opentelemetry.io/otel/trace/tracer.go
+++ b/vendor/go.opentelemetry.io/otel/trace/tracer.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"context"
diff --git a/vendor/go.opentelemetry.io/otel/trace/tracestate.go b/vendor/go.opentelemetry.io/otel/trace/tracestate.go
index e9cb3fd4d..9ac78fa04 100644
--- a/vendor/go.opentelemetry.io/otel/trace/tracestate.go
+++ b/vendor/go.opentelemetry.io/otel/trace/tracestate.go
@@ -1,7 +1,7 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package trace // import "go.opentelemetry.io/otel/trace"
+package trace
import (
"encoding/json"
diff --git a/vendor/go.opentelemetry.io/otel/version.go b/vendor/go.opentelemetry.io/otel/version.go
index 72746acfd..ea7903096 100644
--- a/vendor/go.opentelemetry.io/otel/version.go
+++ b/vendor/go.opentelemetry.io/otel/version.go
@@ -1,9 +1,9 @@
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
-package otel // import "go.opentelemetry.io/otel"
+package otel
// Version is the current release version of OpenTelemetry in use.
func Version() string {
- return "1.44.0"
+ return "1.45.0"
}
diff --git a/vendor/go.opentelemetry.io/otel/versions.yaml b/vendor/go.opentelemetry.io/otel/versions.yaml
index d6dbf803e..3b1ad7301 100644
--- a/vendor/go.opentelemetry.io/otel/versions.yaml
+++ b/vendor/go.opentelemetry.io/otel/versions.yaml
@@ -3,7 +3,7 @@
module-sets:
stable-v1:
- version: v1.44.0
+ version: v1.45.0
modules:
- go.opentelemetry.io/otel
- go.opentelemetry.io/otel/bridge/opencensus
@@ -22,12 +22,12 @@ module-sets:
- go.opentelemetry.io/otel/sdk/metric
- go.opentelemetry.io/otel/trace
experimental-metrics:
- version: v0.66.0
+ version: v0.67.0
modules:
- go.opentelemetry.io/otel/exporters/prometheus
- go.opentelemetry.io/otel/metric/x
experimental-logs:
- version: v0.20.0
+ version: v0.21.0
modules:
- go.opentelemetry.io/otel/log
- go.opentelemetry.io/otel/log/logtest
@@ -37,7 +37,7 @@ module-sets:
- go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp
- go.opentelemetry.io/otel/exporters/stdout/stdoutlog
experimental-schema:
- version: v0.0.17
+ version: v0.0.18
modules:
- go.opentelemetry.io/otel/schema
excluded-modules:
diff --git a/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb b/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb
index 04696351eeeef14cbbd69fd1f4250530b1fbfd56..ad35ea4c449a6b23a78974a905b3fcba120223c6 100644
GIT binary patch
delta 50
zcmbQmxSw&t6m2eLiGDvNNe)H>4lG0U`MWs{jB1
diff --git a/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go b/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go
index 65aaf4d21..58aeff845 100644
--- a/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go
+++ b/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go
@@ -26,6 +26,7 @@ const (
Edition_EDITION_PROTO3_enum_value = 999
Edition_EDITION_2023_enum_value = 1000
Edition_EDITION_2024_enum_value = 1001
+ Edition_EDITION_2026_enum_value = 1002
Edition_EDITION_UNSTABLE_enum_value = 9999
Edition_EDITION_1_TEST_ONLY_enum_value = 1
Edition_EDITION_2_TEST_ONLY_enum_value = 2
@@ -806,11 +807,13 @@ const (
FieldOptions_FeatureSupport_EditionDeprecated_field_name protoreflect.Name = "edition_deprecated"
FieldOptions_FeatureSupport_DeprecationWarning_field_name protoreflect.Name = "deprecation_warning"
FieldOptions_FeatureSupport_EditionRemoved_field_name protoreflect.Name = "edition_removed"
+ FieldOptions_FeatureSupport_RemovalError_field_name protoreflect.Name = "removal_error"
FieldOptions_FeatureSupport_EditionIntroduced_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.edition_introduced"
FieldOptions_FeatureSupport_EditionDeprecated_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.edition_deprecated"
FieldOptions_FeatureSupport_DeprecationWarning_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.deprecation_warning"
FieldOptions_FeatureSupport_EditionRemoved_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.edition_removed"
+ FieldOptions_FeatureSupport_RemovalError_field_fullname protoreflect.FullName = "google.protobuf.FieldOptions.FeatureSupport.removal_error"
)
// Field numbers for google.protobuf.FieldOptions.FeatureSupport.
@@ -819,6 +822,7 @@ const (
FieldOptions_FeatureSupport_EditionDeprecated_field_number protoreflect.FieldNumber = 2
FieldOptions_FeatureSupport_DeprecationWarning_field_number protoreflect.FieldNumber = 3
FieldOptions_FeatureSupport_EditionRemoved_field_number protoreflect.FieldNumber = 4
+ FieldOptions_FeatureSupport_RemovalError_field_number protoreflect.FieldNumber = 5
)
// Names for google.protobuf.OneofOptions.
@@ -1152,6 +1156,7 @@ const (
FeatureSet_ENFORCE_NAMING_STYLE_UNKNOWN_enum_value = 0
FeatureSet_STYLE2024_enum_value = 1
FeatureSet_STYLE_LEGACY_enum_value = 2
+ FeatureSet_STYLE2026_enum_value = 3
)
// Names for google.protobuf.FeatureSet.VisibilityFeature.
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go
index 730331e66..86f0d0926 100644
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go
@@ -546,6 +546,8 @@ func (p *SourcePath) appendFieldOptions_FeatureSupport(b []byte) []byte {
b = p.appendSingularField(b, "deprecation_warning", nil)
case 4:
b = p.appendSingularField(b, "edition_removed", nil)
+ case 5:
+ b = p.appendSingularField(b, "removal_error", nil)
}
return b
}
diff --git a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
index 0b23faa95..a51cb1e54 100644
--- a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
+++ b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
@@ -1,32 +1,9 @@
// Protocol Buffers - Google's data interchange format
-// Copyright 2008 Google Inc. All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// Copyright 2008 Google LLC. All rights reserved.
//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-// * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-// * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
// Author: kenton@google.com (Kenton Varda)
// Based on original Protocol Buffers design by
@@ -69,6 +46,7 @@ const (
// comparison.
Edition_EDITION_2023 Edition = 1000
Edition_EDITION_2024 Edition = 1001
+ Edition_EDITION_2026 Edition = 1002
// A placeholder edition for developing and testing unscheduled features.
Edition_EDITION_UNSTABLE Edition = 9999
// Placeholder editions for testing feature resolution. These should not be
@@ -93,6 +71,7 @@ var (
999: "EDITION_PROTO3",
1000: "EDITION_2023",
1001: "EDITION_2024",
+ 1002: "EDITION_2026",
9999: "EDITION_UNSTABLE",
1: "EDITION_1_TEST_ONLY",
2: "EDITION_2_TEST_ONLY",
@@ -108,6 +87,7 @@ var (
"EDITION_PROTO3": 999,
"EDITION_2023": 1000,
"EDITION_2024": 1001,
+ "EDITION_2026": 1002,
"EDITION_UNSTABLE": 9999,
"EDITION_1_TEST_ONLY": 1,
"EDITION_2_TEST_ONLY": 2,
@@ -1213,6 +1193,7 @@ const (
FeatureSet_ENFORCE_NAMING_STYLE_UNKNOWN FeatureSet_EnforceNamingStyle = 0
FeatureSet_STYLE2024 FeatureSet_EnforceNamingStyle = 1
FeatureSet_STYLE_LEGACY FeatureSet_EnforceNamingStyle = 2
+ FeatureSet_STYLE2026 FeatureSet_EnforceNamingStyle = 3
)
// Enum value maps for FeatureSet_EnforceNamingStyle.
@@ -1221,11 +1202,13 @@ var (
0: "ENFORCE_NAMING_STYLE_UNKNOWN",
1: "STYLE2024",
2: "STYLE_LEGACY",
+ 3: "STYLE2026",
}
FeatureSet_EnforceNamingStyle_value = map[string]int32{
"ENFORCE_NAMING_STYLE_UNKNOWN": 0,
"STYLE2024": 1,
"STYLE_LEGACY": 2,
+ "STYLE2026": 3,
}
)
@@ -4204,8 +4187,11 @@ type FieldOptions_FeatureSupport struct {
// this one, the last default assigned will be used, and proto files will
// not be able to override it.
EditionRemoved *Edition `protobuf:"varint,4,opt,name=edition_removed,json=editionRemoved,enum=google.protobuf.Edition" json:"edition_removed,omitempty"`
- unknownFields protoimpl.UnknownFields
- sizeCache protoimpl.SizeCache
+ // The removal error text if this feature is used after the edition it was
+ // removed in.
+ RemovalError *string `protobuf:"bytes,5,opt,name=removal_error,json=removalError" json:"removal_error,omitempty"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
}
func (x *FieldOptions_FeatureSupport) Reset() {
@@ -4266,6 +4252,13 @@ func (x *FieldOptions_FeatureSupport) GetEditionRemoved() Edition {
return Edition_EDITION_UNKNOWN
}
+func (x *FieldOptions_FeatureSupport) GetRemovalError() string {
+ if x != nil && x.RemovalError != nil {
+ return *x.RemovalError
+ }
+ return ""
+}
+
// The name of the uninterpreted option. Each string represents a segment in
// a dot-separated name. is_extension is true iff a segment represents an
// extension (denoted with parentheses in options specs in .proto files).
@@ -4719,7 +4712,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\aoptions\x18\x03 \x01(\v2&.google.protobuf.ExtensionRangeOptionsR\aoptions\x1a7\n" +
"\rReservedRange\x12\x14\n" +
"\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n" +
- "\x03end\x18\x02 \x01(\x05R\x03end\"\xcc\x04\n" +
+ "\x03end\x18\x02 \x01(\x05R\x03end\"\xd4\x04\n" +
"\x15ExtensionRangeOptions\x12X\n" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x12Y\n" +
"\vdeclaration\x18\x02 \x03(\v22.google.protobuf.ExtensionRangeOptions.DeclarationB\x03\x88\x01\x02R\vdeclaration\x127\n" +
@@ -4735,7 +4728,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x11VerificationState\x12\x0f\n" +
"\vDECLARATION\x10\x00\x12\x0e\n" +
"\n" +
- "UNVERIFIED\x10\x01*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xc1\x06\n" +
+ "UNVERIFIED\x10\x01*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xc1\x06\n" +
"\x14FieldDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
"\x06number\x18\x03 \x01(\x05R\x06number\x12A\n" +
@@ -4810,12 +4803,13 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"outputType\x128\n" +
"\aoptions\x18\x04 \x01(\v2\x1e.google.protobuf.MethodOptionsR\aoptions\x120\n" +
"\x10client_streaming\x18\x05 \x01(\b:\x05falseR\x0fclientStreaming\x120\n" +
- "\x10server_streaming\x18\x06 \x01(\b:\x05falseR\x0fserverStreaming\"\xad\t\n" +
+ "\x10server_streaming\x18\x06 \x01(\b:\x05falseR\x0fserverStreaming\"\xfa\n" +
+ "\n" +
"\vFileOptions\x12!\n" +
"\fjava_package\x18\x01 \x01(\tR\vjavaPackage\x120\n" +
- "\x14java_outer_classname\x18\b \x01(\tR\x12javaOuterClassname\x125\n" +
+ "\x14java_outer_classname\x18\b \x01(\tR\x12javaOuterClassname\x12\xf9\x01\n" +
"\x13java_multiple_files\x18\n" +
- " \x01(\b:\x05falseR\x11javaMultipleFiles\x12D\n" +
+ " \x01(\b:\x05falseB\xc1\x01\xb2\x01\xbd\x01\b\xe6\a \xe9\a*\xb4\x01This behavior is enabled by default in editions 2024 and above. To disable it, you can set `features.(pb.java).nest_in_file_class = YES` on individual messages, enums, or services.R\x11javaMultipleFiles\x12D\n" +
"\x1djava_generate_equals_and_hash\x18\x14 \x01(\bB\x02\x18\x01R\x19javaGenerateEqualsAndHash\x12:\n" +
"\x16java_string_check_utf8\x18\x1b \x01(\b:\x05falseR\x13javaStringCheckUtf8\x12S\n" +
"\foptimize_for\x18\t \x01(\x0e2).google.protobuf.FileOptions.OptimizeMode:\x05SPEEDR\voptimizeFor\x12\x1d\n" +
@@ -4840,7 +4834,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\fOptimizeMode\x12\t\n" +
"\x05SPEED\x10\x01\x12\r\n" +
"\tCODE_SIZE\x10\x02\x12\x10\n" +
- "\fLITE_RUNTIME\x10\x03*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b*\x10+J\x04\b&\x10'R\x14php_generic_services\"\xf4\x03\n" +
+ "\fLITE_RUNTIME\x10\x03*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b*\x10+J\x04\b&\x10'R\x14php_generic_services\"\xfc\x03\n" +
"\x0eMessageOptions\x12<\n" +
"\x17message_set_wire_format\x18\x01 \x01(\b:\x05falseR\x14messageSetWireFormat\x12L\n" +
"\x1fno_standard_descriptor_accessor\x18\x02 \x01(\b:\x05falseR\x1cnoStandardDescriptorAccessor\x12%\n" +
@@ -4850,8 +4844,8 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\tmap_entry\x18\a \x01(\bR\bmapEntry\x12V\n" +
"&deprecated_legacy_json_field_conflicts\x18\v \x01(\bB\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x127\n" +
"\bfeatures\x18\f \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
- "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x04\x10\x05J\x04\b\x05\x10\x06J\x04\b\x06\x10\aJ\x04\b\b\x10\tJ\x04\b\t\x10\n" +
- "\"\xa1\r\n" +
+ "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x04\x10\x05J\x04\b\x05\x10\x06J\x04\b\x06\x10\aJ\x04\b\b\x10\tJ\x04\b\t\x10\n" +
+ "\"\xce\r\n" +
"\fFieldOptions\x12A\n" +
"\x05ctype\x18\x01 \x01(\x0e2#.google.protobuf.FieldOptions.CType:\x06STRINGR\x05ctype\x12\x16\n" +
"\x06packed\x18\x02 \x01(\bR\x06packed\x12G\n" +
@@ -4872,12 +4866,13 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption\x1aZ\n" +
"\x0eEditionDefault\x122\n" +
"\aedition\x18\x03 \x01(\x0e2\x18.google.protobuf.EditionR\aedition\x12\x14\n" +
- "\x05value\x18\x02 \x01(\tR\x05value\x1a\x96\x02\n" +
+ "\x05value\x18\x02 \x01(\tR\x05value\x1a\xbb\x02\n" +
"\x0eFeatureSupport\x12G\n" +
"\x12edition_introduced\x18\x01 \x01(\x0e2\x18.google.protobuf.EditionR\x11editionIntroduced\x12G\n" +
"\x12edition_deprecated\x18\x02 \x01(\x0e2\x18.google.protobuf.EditionR\x11editionDeprecated\x12/\n" +
"\x13deprecation_warning\x18\x03 \x01(\tR\x12deprecationWarning\x12A\n" +
- "\x0fedition_removed\x18\x04 \x01(\x0e2\x18.google.protobuf.EditionR\x0eeditionRemoved\"/\n" +
+ "\x0fedition_removed\x18\x04 \x01(\x0e2\x18.google.protobuf.EditionR\x0eeditionRemoved\x12#\n" +
+ "\rremoval_error\x18\x05 \x01(\tR\fremovalError\"/\n" +
"\x05CType\x12\n" +
"\n" +
"\x06STRING\x10\x00\x12\b\n" +
@@ -4901,10 +4896,10 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x10TARGET_TYPE_ENUM\x10\x06\x12\x1a\n" +
"\x16TARGET_TYPE_ENUM_ENTRY\x10\a\x12\x17\n" +
"\x13TARGET_TYPE_SERVICE\x10\b\x12\x16\n" +
- "\x12TARGET_TYPE_METHOD\x10\t*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x04\x10\x05J\x04\b\x12\x10\x13\"\xac\x01\n" +
+ "\x12TARGET_TYPE_METHOD\x10\t*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x04\x10\x05J\x04\b\x12\x10\x13\"\xb4\x01\n" +
"\fOneofOptions\x127\n" +
"\bfeatures\x18\x01 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
- "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xd1\x02\n" +
+ "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xd9\x02\n" +
"\vEnumOptions\x12\x1f\n" +
"\vallow_alias\x18\x02 \x01(\bR\n" +
"allowAlias\x12%\n" +
@@ -4913,7 +4908,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"deprecated\x12V\n" +
"&deprecated_legacy_json_field_conflicts\x18\x06 \x01(\bB\x02\x18\x01R\"deprecatedLegacyJsonFieldConflicts\x127\n" +
"\bfeatures\x18\a \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12X\n" +
- "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x05\x10\x06\"\xd8\x02\n" +
+ "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02J\x04\b\x05\x10\x06\"\xe0\x02\n" +
"\x10EnumValueOptions\x12%\n" +
"\n" +
"deprecated\x18\x01 \x01(\b:\x05falseR\n" +
@@ -4921,13 +4916,13 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\bfeatures\x18\x02 \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12(\n" +
"\fdebug_redact\x18\x03 \x01(\b:\x05falseR\vdebugRedact\x12U\n" +
"\x0ffeature_support\x18\x04 \x01(\v2,.google.protobuf.FieldOptions.FeatureSupportR\x0efeatureSupport\x12X\n" +
- "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xd5\x01\n" +
+ "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xdd\x01\n" +
"\x0eServiceOptions\x127\n" +
"\bfeatures\x18\" \x01(\v2\x1b.google.protobuf.FeatureSetR\bfeatures\x12%\n" +
"\n" +
"deprecated\x18! \x01(\b:\x05falseR\n" +
"deprecated\x12X\n" +
- "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\x99\x03\n" +
+ "\x14uninterpreted_option\x18\xe7\a \x03(\v2$.google.protobuf.UninterpretedOptionR\x13uninterpretedOption*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\xa1\x03\n" +
"\rMethodOptions\x12%\n" +
"\n" +
"deprecated\x18! \x01(\b:\x05falseR\n" +
@@ -4939,7 +4934,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x13IDEMPOTENCY_UNKNOWN\x10\x00\x12\x13\n" +
"\x0fNO_SIDE_EFFECTS\x10\x01\x12\x0e\n" +
"\n" +
- "IDEMPOTENT\x10\x02*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\x9a\x03\n" +
+ "IDEMPOTENT\x10\x02*\x06\b\xde\a\x10\xe7\a*\t\b\xe8\a\x10\x80\x80\x80\x80\x02\"\x9a\x03\n" +
"\x13UninterpretedOption\x12A\n" +
"\x04name\x18\x02 \x03(\v2-.google.protobuf.UninterpretedOption.NamePartR\x04name\x12)\n" +
"\x10identifier_value\x18\x03 \x01(\tR\x0fidentifierValue\x12,\n" +
@@ -4950,7 +4945,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x0faggregate_value\x18\b \x01(\tR\x0eaggregateValue\x1aJ\n" +
"\bNamePart\x12\x1b\n" +
"\tname_part\x18\x01 \x02(\tR\bnamePart\x12!\n" +
- "\fis_extension\x18\x02 \x02(\bR\visExtension\"\x8e\x0f\n" +
+ "\fis_extension\x18\x02 \x02(\bR\visExtension\"\xae\x0f\n" +
"\n" +
"FeatureSet\x12\x91\x01\n" +
"\x0efield_presence\x18\x01 \x01(\x0e2).google.protobuf.FeatureSet.FieldPresenceB?\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\bEXPLICIT\x18\x84\a\xa2\x01\r\x12\bIMPLICIT\x18\xe7\a\xa2\x01\r\x12\bEXPLICIT\x18\xe8\a\xb2\x01\x03\b\xe8\aR\rfieldPresence\x12l\n" +
@@ -4960,8 +4955,8 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x10message_encoding\x18\x05 \x01(\x0e2+.google.protobuf.FeatureSet.MessageEncodingB&\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\x14\x12\x0fLENGTH_PREFIXED\x18\x84\a\xb2\x01\x03\b\xe8\aR\x0fmessageEncoding\x12\x82\x01\n" +
"\vjson_format\x18\x06 \x01(\x0e2&.google.protobuf.FeatureSet.JsonFormatB9\x88\x01\x01\x98\x01\x03\x98\x01\x06\x98\x01\x01\xa2\x01\x17\x12\x12LEGACY_BEST_EFFORT\x18\x84\a\xa2\x01\n" +
"\x12\x05ALLOW\x18\xe7\a\xb2\x01\x03\b\xe8\aR\n" +
- "jsonFormat\x12\xab\x01\n" +
- "\x14enforce_naming_style\x18\a \x01(\x0e2..google.protobuf.FeatureSet.EnforceNamingStyleBI\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\a\x98\x01\b\x98\x01\t\xa2\x01\x11\x12\fSTYLE_LEGACY\x18\x84\a\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x12enforceNamingStyle\x12\xb9\x01\n" +
+ "jsonFormat\x12\xbc\x01\n" +
+ "\x14enforce_naming_style\x18\a \x01(\x0e2..google.protobuf.FeatureSet.EnforceNamingStyleBZ\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\a\x98\x01\b\x98\x01\t\xa2\x01\x11\x12\fSTYLE_LEGACY\x18\x84\a\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\a\xa2\x01\x0e\x12\tSTYLE2026\x18\x8fN\xb2\x01\x03\b\xe9\aR\x12enforceNamingStyle\x12\xb9\x01\n" +
"\x19default_symbol_visibility\x18\b \x01(\x0e2E.google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibilityB6\x88\x01\x02\x98\x01\x01\xa2\x01\x0f\x12\n" +
"EXPORT_ALL\x18\x84\a\xa2\x01\x15\x12\x10EXPORT_TOP_LEVEL\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x17defaultSymbolVisibility\x1a\xa1\x01\n" +
"\x11VisibilityFeature\"\x81\x01\n" +
@@ -5001,11 +4996,12 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"JsonFormat\x12\x17\n" +
"\x13JSON_FORMAT_UNKNOWN\x10\x00\x12\t\n" +
"\x05ALLOW\x10\x01\x12\x16\n" +
- "\x12LEGACY_BEST_EFFORT\x10\x02\"W\n" +
+ "\x12LEGACY_BEST_EFFORT\x10\x02\"f\n" +
"\x12EnforceNamingStyle\x12 \n" +
"\x1cENFORCE_NAMING_STYLE_UNKNOWN\x10\x00\x12\r\n" +
"\tSTYLE2024\x10\x01\x12\x10\n" +
- "\fSTYLE_LEGACY\x10\x02*\x06\b\xe8\a\x10\x8bN*\x06\b\x8bN\x10\x90N*\x06\b\x90N\x10\x91NJ\x06\b\xe7\a\x10\xe8\a\"\xef\x03\n" +
+ "\fSTYLE_LEGACY\x10\x02\x12\r\n" +
+ "\tSTYLE2026\x10\x03*\x06\b\xe8\a\x10\x8bN*\x06\b\x8bN\x10\x90N*\x06\b\x90N\x10\x91NJ\x06\b\xe7\a\x10\xe8\a\"\xef\x03\n" +
"\x12FeatureSetDefaults\x12X\n" +
"\bdefaults\x18\x01 \x03(\v2<.google.protobuf.FeatureSetDefaults.FeatureSetEditionDefaultR\bdefaults\x12A\n" +
"\x0fminimum_edition\x18\x04 \x01(\x0e2\x18.google.protobuf.EditionR\x0eminimumEdition\x12A\n" +
@@ -5037,14 +5033,15 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\bSemantic\x12\b\n" +
"\x04NONE\x10\x00\x12\a\n" +
"\x03SET\x10\x01\x12\t\n" +
- "\x05ALIAS\x10\x02*\xbe\x02\n" +
+ "\x05ALIAS\x10\x02*\xd1\x02\n" +
"\aEdition\x12\x13\n" +
"\x0fEDITION_UNKNOWN\x10\x00\x12\x13\n" +
"\x0eEDITION_LEGACY\x10\x84\a\x12\x13\n" +
"\x0eEDITION_PROTO2\x10\xe6\a\x12\x13\n" +
"\x0eEDITION_PROTO3\x10\xe7\a\x12\x11\n" +
"\fEDITION_2023\x10\xe8\a\x12\x11\n" +
- "\fEDITION_2024\x10\xe9\a\x12\x15\n" +
+ "\fEDITION_2024\x10\xe9\a\x12\x11\n" +
+ "\fEDITION_2026\x10\xea\a\x12\x15\n" +
"\x10EDITION_UNSTABLE\x10\x8fN\x12\x17\n" +
"\x13EDITION_1_TEST_ONLY\x10\x01\x12\x17\n" +
"\x13EDITION_2_TEST_ONLY\x10\x02\x12\x1d\n" +
diff --git a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
index 1ff0d1494..510894f2b 100644
--- a/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/anypb/any.pb.go
@@ -128,120 +128,66 @@ import (
// `Any` contains an arbitrary serialized protocol buffer message along with a
// URL that describes the type of the serialized message.
//
-// Protobuf library provides support to pack/unpack Any values in the form
-// of utility functions or additional generated methods of the Any type.
-//
-// Example 1: Pack and unpack a message in C++.
-//
-// Foo foo = ...;
-// Any any;
-// any.PackFrom(foo);
-// ...
-// if (any.UnpackTo(&foo)) {
-// ...
-// }
-//
-// Example 2: Pack and unpack a message in Java.
-//
-// Foo foo = ...;
-// Any any = Any.pack(foo);
-// ...
-// if (any.is(Foo.class)) {
-// foo = any.unpack(Foo.class);
-// }
-// // or ...
-// if (any.isSameTypeAs(Foo.getDefaultInstance())) {
-// foo = any.unpack(Foo.getDefaultInstance());
-// }
-//
-// Example 3: Pack and unpack a message in Python.
-//
-// foo = Foo(...)
-// any = Any()
-// any.Pack(foo)
-// ...
-// if any.Is(Foo.DESCRIPTOR):
-// any.Unpack(foo)
-// ...
-//
-// Example 4: Pack and unpack a message in Go
-//
-// foo := &pb.Foo{...}
-// any, err := anypb.New(foo)
-// if err != nil {
-// ...
-// }
-// ...
-// foo := &pb.Foo{}
-// if err := any.UnmarshalTo(foo); err != nil {
-// ...
-// }
-//
-// The pack methods provided by protobuf library will by default use
-// 'type.googleapis.com/full.type.name' as the type URL and the unpack
-// methods only use the fully qualified type name after the last '/'
-// in the type URL, for example "foo.bar.com/x/y.z" will yield type
-// name "y.z".
-//
-// JSON
-// ====
-// The JSON representation of an `Any` value uses the regular
-// representation of the deserialized, embedded message, with an
-// additional field `@type` which contains the type URL. Example:
-//
-// package google.profile;
-// message Person {
-// string first_name = 1;
-// string last_name = 2;
-// }
-//
-// {
-// "@type": "type.googleapis.com/google.profile.Person",
-// "firstName": ,
-// "lastName":
-// }
-//
-// If the embedded message type is well-known and has a custom JSON
-// representation, that representation will be embedded adding a field
-// `value` which holds the custom JSON in addition to the `@type`
-// field. Example (for message [google.protobuf.Duration][]):
-//
-// {
-// "@type": "type.googleapis.com/google.protobuf.Duration",
-// "value": "1.212s"
-// }
+// In its binary encoding, an `Any` is an ordinary message; but in other wire
+// forms like JSON, it has a special encoding. The format of the type URL is
+// described on the `type_url` field.
+//
+// Protobuf APIs provide utilities to interact with `Any` values:
+//
+// - A 'pack' operation accepts a message and constructs a generic `Any` wrapper
+// around it.
+// - An 'unpack' operation reads the content of an `Any` message, either into an
+// existing message or a new one. Unpack operations must check the type of the
+// value they unpack against the declared `type_url`.
+// - An 'is' operation decides whether an `Any` contains a message of the given
+// type, i.e. whether it can 'unpack' that type.
+//
+// The JSON format representation of an `Any` follows one of these cases:
+//
+// - For types without special-cased JSON encodings, the JSON format
+// representation of the `Any` is the same as that of the message, with an
+// additional `@type` field which contains the type URL.
+// - For types with special-cased JSON encodings (typically called 'well-known'
+// types, listed in https://protobuf.dev/programming-guides/json/#any), the
+// JSON format representation has a key `@type` which contains the type URL
+// and a key `value` which contains the JSON-serialized value.
+//
+// The text format representation of an `Any` is like a message with one field
+// whose name is the type URL in brackets. For example, an `Any` containing a
+// `foo.Bar` message may be written `[type.googleapis.com/foo.Bar] { a: 2 }`.
type Any struct {
state protoimpl.MessageState `protogen:"open.v1"`
- // A URL/resource name that uniquely identifies the type of the serialized
- // protocol buffer message. This string must contain at least
- // one "/" character. The last segment of the URL's path must represent
- // the fully qualified name of the type (as in
- // `path/google.protobuf.Duration`). The name should be in a canonical form
- // (e.g., leading "." is not accepted).
+ // Identifies the type of the serialized Protobuf message with a URI reference
+ // consisting of a prefix ending in a slash and the fully-qualified type name.
+ //
+ // Example: type.googleapis.com/google.protobuf.StringValue
//
- // In practice, teams usually precompile into the binary all types that they
- // expect it to use in the context of Any. However, for URLs which use the
- // scheme `http`, `https`, or no scheme, one can optionally set up a type
- // server that maps type URLs to message definitions as follows:
+ // This string must contain at least one `/` character, and the content after
+ // the last `/` must be the fully-qualified name of the type in canonical
+ // form, without a leading dot. Do not write a scheme on these URI references
+ // so that clients do not attempt to contact them.
//
- // - If no scheme is provided, `https` is assumed.
- // - An HTTP GET on the URL must yield a [google.protobuf.Type][]
- // value in binary format, or produce an error.
- // - Applications are allowed to cache lookup results based on the
- // URL, or have them precompiled into a binary to avoid any
- // lookup. Therefore, binary compatibility needs to be preserved
- // on changes to types. (Use versioned type names to manage
- // breaking changes.)
+ // The prefix is arbitrary and Protobuf implementations are expected to
+ // simply strip off everything up to and including the last `/` to identify
+ // the type. `type.googleapis.com/` is a common default prefix that some
+ // legacy implementations require. This prefix does not indicate the origin of
+ // the type, and URIs containing it are not expected to respond to any
+ // requests.
//
- // Note: this functionality is not currently available in the official
- // protobuf release, and it is not used for type URLs beginning with
- // type.googleapis.com. As of May 2023, there are no widely used type server
- // implementations and no plans to implement one.
+ // All type URL strings must be legal URI references with the additional
+ // restriction (for the text format) that the content of the reference
+ // must consist only of alphanumeric characters, percent-encoded escapes, and
+ // characters in the following set (not including the outer backticks):
+ // `/-.~_!$&()*+,;=`. Despite our allowing percent encodings, implementations
+ // should not unescape them to prevent confusion with existing parsers. For
+ // example, `type.googleapis.com%2FFoo` should be rejected.
//
- // Schemes other than `http`, `https` (or the empty scheme) might be
- // used with implementation specific semantics.
+ // In the original design of `Any`, the possibility of launching a type
+ // resolution service at these type URLs was considered but Protobuf never
+ // implemented one and considers contacting these URLs to be problematic and
+ // a potential security issue. Do not attempt to contact type URLs.
TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"`
- // Must be a valid serialized protocol buffer of the above specified type.
+ // Holds a Protobuf serialization of the type described by type_url.
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
diff --git a/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go b/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go
index 91ee89a5c..4a0437911 100644
--- a/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/fieldmaskpb/field_mask.pb.go
@@ -197,24 +197,22 @@ import (
// An implementation may provide options to override this default behavior for
// repeated and message fields.
//
-// In order to reset a field's value to the default, the field must
-// be in the mask and set to the default value in the provided resource.
-// Hence, in order to reset all fields of a resource, provide a default
-// instance of the resource and set all fields in the mask, or do
-// not provide a mask as described below.
-//
-// If a field mask is not present on update, the operation applies to
-// all fields (as if a field mask of all fields has been specified).
-// Note that in the presence of schema evolution, this may mean that
-// fields the client does not know and has therefore not filled into
-// the request will be reset to their default. If this is unwanted
-// behavior, a specific service may require a client to always specify
-// a field mask, producing an error if not.
-//
-// As with get operations, the location of the resource which
-// describes the updated values in the request message depends on the
-// operation kind. In any case, the effect of the field mask is
-// required to be honored by the API.
+// Note that libraries which implement FieldMask resolution have various
+// different behaviors in the face of empty masks or the special "*" mask.
+// When implementing a service you should confirm these cases have the
+// appropriate behavior in the underlying FieldMask library that you desire,
+// and you may need to special case those cases in your application code if
+// the underlying field mask library behavior differs from your intended
+// service semantics.
+//
+// Update methods implementing https://google.aip.dev/134
+// - MUST support the special value * meaning "full replace"
+// - MUST treat an omitted field mask as "replace fields which are present".
+//
+// Other methods implementing https://google.aip.dev/157
+// - SHOULD support the special value "*" to mean "get all".
+// - MUST treat an omitted field mask to mean "get all", unless otherwise
+// documented.
//
// ## Considerations for HTTP REST
//
diff --git a/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go b/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
index 30411b728..8325a5048 100644
--- a/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/structpb/struct.pb.go
@@ -131,10 +131,15 @@ import (
unsafe "unsafe"
)
-// `NullValue` is a singleton enumeration to represent the null value for the
-// `Value` type union.
+// Represents a JSON `null`.
//
-// The JSON representation for `NullValue` is JSON `null`.
+// `NullValue` is a sentinel, using an enum with only one value to represent
+// the null value for the `Value` type union.
+//
+// A field of type `NullValue` with any value other than `0` is considered
+// invalid. Most ProtoJSON serializers will emit a Value with a `null_value` set
+// as a JSON `null` regardless of the integer value, and so will round trip to
+// a `0` value.
type NullValue int32
const (
@@ -179,14 +184,19 @@ func (NullValue) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_struct_proto_rawDescGZIP(), []int{0}
}
-// `Struct` represents a structured data value, consisting of fields
-// which map to dynamically typed values. In some languages, `Struct`
-// might be supported by a native representation. For example, in
-// scripting languages like JS a struct is represented as an
-// object. The details of that representation are described together
-// with the proto support for the language.
+// Represents a JSON object.
+//
+// An unordered key-value map, intending to perfectly capture the semantics of a
+// JSON object. This enables parsing any arbitrary JSON payload as a message
+// field in ProtoJSON format.
+//
+// This follows RFC 8259 guidelines for interoperable JSON: notably this type
+// cannot represent large Int64 values or `NaN`/`Infinity` numbers,
+// since the JSON format generally does not support those values in its number
+// type.
//
-// The JSON representation for `Struct` is JSON object.
+// If you do not intend to parse arbitrary JSON into your message, a custom
+// typed message should be preferred instead of using this type.
type Struct struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Unordered map of dynamically typed values.
@@ -269,12 +279,12 @@ func (x *Struct) GetFields() map[string]*Value {
return nil
}
+// Represents a JSON value.
+//
// `Value` represents a dynamically typed value which can be either
// null, a number, a string, a boolean, a recursive struct value, or a
// list of values. A producer of value is expected to set one of these
-// variants. Absence of any variant indicates an error.
-//
-// The JSON representation for `Value` is JSON value.
+// variants. Absence of any variant is an invalid state.
type Value struct {
state protoimpl.MessageState `protogen:"open.v1"`
// The kind of value.
@@ -548,32 +558,35 @@ type isValue_Kind interface {
}
type Value_NullValue struct {
- // Represents a null value.
+ // Represents a JSON `null`.
NullValue NullValue `protobuf:"varint,1,opt,name=null_value,json=nullValue,proto3,enum=google.protobuf.NullValue,oneof"`
}
type Value_NumberValue struct {
- // Represents a double value.
+ // Represents a JSON number. Must not be `NaN`, `Infinity` or
+ // `-Infinity`, since those are not supported in JSON. This also cannot
+ // represent large Int64 values, since JSON format generally does not
+ // support them in its number type.
NumberValue float64 `protobuf:"fixed64,2,opt,name=number_value,json=numberValue,proto3,oneof"`
}
type Value_StringValue struct {
- // Represents a string value.
+ // Represents a JSON string.
StringValue string `protobuf:"bytes,3,opt,name=string_value,json=stringValue,proto3,oneof"`
}
type Value_BoolValue struct {
- // Represents a boolean value.
+ // Represents a JSON boolean (`true` or `false` literal in JSON).
BoolValue bool `protobuf:"varint,4,opt,name=bool_value,json=boolValue,proto3,oneof"`
}
type Value_StructValue struct {
- // Represents a structured value.
+ // Represents a JSON object.
StructValue *Struct `protobuf:"bytes,5,opt,name=struct_value,json=structValue,proto3,oneof"`
}
type Value_ListValue struct {
- // Represents a repeated `Value`.
+ // Represents a JSON array.
ListValue *ListValue `protobuf:"bytes,6,opt,name=list_value,json=listValue,proto3,oneof"`
}
@@ -589,9 +602,7 @@ func (*Value_StructValue) isValue_Kind() {}
func (*Value_ListValue) isValue_Kind() {}
-// `ListValue` is a wrapper around a repeated field of values.
-//
-// The JSON representation for `ListValue` is JSON array.
+// Represents a JSON array.
type ListValue struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Repeated field of dynamically typed values.
diff --git a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
index 484c21fd5..2cd60946c 100644
--- a/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
+++ b/vendor/google.golang.org/protobuf/types/known/timestamppb/timestamp.pb.go
@@ -153,8 +153,8 @@ import (
// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
-// is required. A proto3 JSON serializer should always use UTC (as indicated by
-// "Z") when printing the Timestamp type and a proto3 JSON parser should be
+// is required. A ProtoJSON serializer should always use UTC (as indicated by
+// "Z") when printing the Timestamp type and a ProtoJSON parser should be
// able to accept both UTC and other timezones (as indicated by an offset).
//
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
@@ -173,7 +173,7 @@ import (
type Timestamp struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
- // be between -315576000000 and 315576000000 inclusive (which corresponds to
+ // be between -62135596800 and 253402300799 inclusive (which corresponds to
// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
// Non-negative fractions of a second at nanosecond resolution. This field is
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 180df9138..ffc1277c5 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1,3 +1,15 @@
+# charm.land/bubbles/v2 v2.1.0
+## explicit; go 1.25.0
+charm.land/bubbles/v2/cursor
+charm.land/bubbles/v2/internal/runeutil
+charm.land/bubbles/v2/key
+charm.land/bubbles/v2/textinput
+# charm.land/bubbletea/v2 v2.0.5
+## explicit; go 1.25.0
+charm.land/bubbletea/v2
+# charm.land/lipgloss/v2 v2.0.3
+## explicit; go 1.25.0
+charm.land/lipgloss/v2
# dario.cat/mergo v1.0.2
## explicit; go 1.13
dario.cat/mergo
@@ -179,7 +191,7 @@ github.com/IBM/go-sdk-core/v5/core
## explicit; go 1.25.0
github.com/IBM/platform-services-go-sdk/common
github.com/IBM/platform-services-go-sdk/resourcecontrollerv2
-# github.com/IBM/vpc-go-sdk v0.87.1
+# github.com/IBM/vpc-go-sdk v0.88.0
## explicit; go 1.25.0
github.com/IBM/vpc-go-sdk/common
github.com/IBM/vpc-go-sdk/vpcv1
@@ -237,7 +249,7 @@ github.com/aws/amazon-ec2-instance-selector/v3/pkg/instancetypes
github.com/aws/amazon-ec2-instance-selector/v3/pkg/selector
github.com/aws/amazon-ec2-instance-selector/v3/pkg/selector/outputs
github.com/aws/amazon-ec2-instance-selector/v3/pkg/sorter
-# github.com/aws/aws-sdk-go-v2 v1.43.3
+# github.com/aws/aws-sdk-go-v2 v1.43.4
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/aws
github.com/aws/aws-sdk-go-v2/aws/arn
@@ -286,10 +298,10 @@ github.com/aws/aws-sdk-go-v2/credentials/stscreds
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/feature/ec2/imds
github.com/aws/aws-sdk-go-v2/feature/ec2/imds/internal/config
-# github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.34
+# github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.35
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/internal/configsources
-# github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.34
+# github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.35
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2
# github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.35
@@ -297,19 +309,19 @@ github.com/aws/aws-sdk-go-v2/internal/endpoints/v2
github.com/aws/aws-sdk-go-v2/internal/v4a
github.com/aws/aws-sdk-go-v2/internal/v4a/internal/crypto
github.com/aws/aws-sdk-go-v2/internal/v4a/internal/v4
-# github.com/aws/aws-sdk-go-v2/service/ec2 v1.318.1
+# github.com/aws/aws-sdk-go-v2/service/ec2 v1.319.1
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/service/ec2
github.com/aws/aws-sdk-go-v2/service/ec2/internal/endpoints
github.com/aws/aws-sdk-go-v2/service/ec2/types
-# github.com/aws/aws-sdk-go-v2/service/ecs v1.89.3
+# github.com/aws/aws-sdk-go-v2/service/ecs v1.90.0
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/service/ecs
github.com/aws/aws-sdk-go-v2/service/ecs/document
github.com/aws/aws-sdk-go-v2/service/ecs/internal/document
github.com/aws/aws-sdk-go-v2/service/ecs/internal/endpoints
github.com/aws/aws-sdk-go-v2/service/ecs/types
-# github.com/aws/aws-sdk-go-v2/service/iam v1.57.1
+# github.com/aws/aws-sdk-go-v2/service/iam v1.58.1
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/service/iam
github.com/aws/aws-sdk-go-v2/service/iam/internal/endpoints
@@ -320,7 +332,7 @@ github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding
# github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.27
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/service/internal/checksum
-# github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.34
+# github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.35
## explicit; go 1.24
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url
# github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.35
@@ -429,18 +441,28 @@ github.com/charmbracelet/colorprofile
# github.com/charmbracelet/lipgloss v1.1.0
## explicit; go 1.18
github.com/charmbracelet/lipgloss
+# github.com/charmbracelet/ultraviolet v0.0.0-20260413211237-bd52878bcec2
+## explicit; go 1.25.0
+github.com/charmbracelet/ultraviolet
# github.com/charmbracelet/x/ansi v0.11.7
## explicit; go 1.24.2
github.com/charmbracelet/x/ansi
+github.com/charmbracelet/x/ansi/kitty
github.com/charmbracelet/x/ansi/parser
# github.com/charmbracelet/x/cellbuf v0.0.15
## explicit; go 1.24.2
github.com/charmbracelet/x/cellbuf
-# github.com/charmbracelet/x/exp/golden v0.0.0-20260730164118-7e2d3e6c5238
+# github.com/charmbracelet/x/exp/golden v0.0.0-20260803091719-3755ebad01b1
## explicit; go 1.24.0
# github.com/charmbracelet/x/term v0.2.2
## explicit; go 1.24.0
github.com/charmbracelet/x/term
+# github.com/charmbracelet/x/termios v0.1.1
+## explicit; go 1.18
+github.com/charmbracelet/x/termios
+# github.com/charmbracelet/x/windows v0.2.2
+## explicit; go 1.23.0
+github.com/charmbracelet/x/windows
# github.com/cheggaaa/pb v1.0.29
## explicit; go 1.12
github.com/cheggaaa/pb
@@ -484,8 +506,8 @@ github.com/emirpasic/gods/utils
# github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f
## explicit; go 1.16
github.com/erikgeiser/coninput
-# github.com/evertras/bubble-table v0.17.1
-## explicit; go 1.18
+# github.com/evertras/bubble-table v0.22.3
+## explicit; go 1.25.0
github.com/evertras/bubble-table/table
# github.com/fsnotify/fsnotify v1.10.1
## explicit; go 1.23
@@ -709,7 +731,7 @@ github.com/golang/glog/internal/stackdump
# github.com/google/uuid v1.6.0
## explicit
github.com/google/uuid
-# github.com/grpc-ecosystem/grpc-gateway/v2 v2.29.0
+# github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0
## explicit; go 1.25.0
github.com/grpc-ecosystem/grpc-gateway/v2/internal/httprule
github.com/grpc-ecosystem/grpc-gateway/v2/runtime
@@ -808,11 +830,6 @@ github.com/muesli/ansi/compressor
# github.com/muesli/cancelreader v0.2.2
## explicit; go 1.17
github.com/muesli/cancelreader
-# github.com/muesli/reflow v0.3.0
-## explicit; go 1.13
-github.com/muesli/reflow/ansi
-github.com/muesli/reflow/truncate
-github.com/muesli/reflow/wordwrap
# github.com/muesli/termenv v0.16.0
## explicit; go 1.17
github.com/muesli/termenv
@@ -875,13 +892,13 @@ github.com/pkg/term/termios
github.com/pulumi/appdash
github.com/pulumi/appdash/internal/wire
github.com/pulumi/appdash/opentracing
-# github.com/pulumi/pulumi-aws-native/sdk v1.73.1
+# github.com/pulumi/pulumi-aws-native/sdk v1.74.1
## explicit; go 1.25.11
github.com/pulumi/pulumi-aws-native/sdk/go/aws
github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal
github.com/pulumi/pulumi-aws-native/sdk/go/aws/scheduler
github.com/pulumi/pulumi-aws-native/sdk/go/aws/ssm
-# github.com/pulumi/pulumi-aws/sdk/v7 v7.39.0
+# github.com/pulumi/pulumi-aws/sdk/v7 v7.40.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-aws/sdk/v7/go/aws
github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling
@@ -898,28 +915,28 @@ github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3
github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/awsx
github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/ecs
github.com/pulumi/pulumi-awsx/sdk/v3/go/awsx/internal
-# github.com/pulumi/pulumi-azure-native-sdk/authorization/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/authorization/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/authorization/v3
-# github.com/pulumi/pulumi-azure-native-sdk/compute/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/compute/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/compute/v3
-# github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/containerservice/v3
-# github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/managedidentity/v3
-# github.com/pulumi/pulumi-azure-native-sdk/network/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/network/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/network/v3
-# github.com/pulumi/pulumi-azure-native-sdk/resources/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/resources/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/resources/v3
-# github.com/pulumi/pulumi-azure-native-sdk/storage/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/storage/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/storage/v3
-# github.com/pulumi/pulumi-azure-native-sdk/v3 v3.24.0
+# github.com/pulumi/pulumi-azure-native-sdk/v3 v3.25.0
## explicit; go 1.25.11
github.com/pulumi/pulumi-azure-native-sdk/v3/utilities
# github.com/pulumi/pulumi-command/sdk v1.2.1
@@ -1021,7 +1038,7 @@ github.com/pulumi/pulumi-random/sdk/v4/go/random/internal
## explicit; go 1.25.11
github.com/pulumi/pulumi-tls/sdk/v5/go/tls
github.com/pulumi/pulumi-tls/sdk/v5/go/tls/internal
-# github.com/pulumi/pulumi/sdk/v3 v3.255.0
+# github.com/pulumi/pulumi/sdk/v3 v3.256.0
## explicit; go 1.25.11
github.com/pulumi/pulumi/sdk/v3
github.com/pulumi/pulumi/sdk/v3/go/auto
@@ -1111,7 +1128,7 @@ github.com/pulumi/pulumi/sdk/v3/proto/go/codegen
# github.com/rivo/uniseg v0.4.7
## explicit; go 1.18
github.com/rivo/uniseg
-# github.com/rogpeppe/go-internal v1.15.0
+# github.com/rogpeppe/go-internal v1.16.0
## explicit; go 1.25
github.com/rogpeppe/go-internal/internal/syscall/windows
github.com/rogpeppe/go-internal/internal/syscall/windows/sysdll
@@ -1199,10 +1216,10 @@ github.com/zclconf/go-cty/cty/set
## explicit; go 1.24.0
go.opentelemetry.io/auto/sdk
go.opentelemetry.io/auto/sdk/internal/telemetry
-# go.opentelemetry.io/collector/featuregate v1.63.0
+# go.opentelemetry.io/collector/featuregate v1.64.0
## explicit; go 1.25.0
go.opentelemetry.io/collector/featuregate
-# go.opentelemetry.io/collector/pdata v1.63.0
+# go.opentelemetry.io/collector/pdata v1.64.0
## explicit; go 1.25.0
go.opentelemetry.io/collector/pdata/internal
go.opentelemetry.io/collector/pdata/internal/json
@@ -1212,10 +1229,10 @@ go.opentelemetry.io/collector/pdata/internal/proto
go.opentelemetry.io/collector/pdata/pcommon
go.opentelemetry.io/collector/pdata/plog
go.opentelemetry.io/collector/pdata/ptrace
-# go.opentelemetry.io/contrib/bridges/otelslog v0.19.0
+# go.opentelemetry.io/contrib/bridges/otelslog v0.20.0
## explicit; go 1.25.0
go.opentelemetry.io/contrib/bridges/otelslog
-# go.opentelemetry.io/otel v1.44.0
+# go.opentelemetry.io/otel v1.45.0
## explicit; go 1.25.0
go.opentelemetry.io/otel
go.opentelemetry.io/otel/attribute
@@ -1227,12 +1244,13 @@ go.opentelemetry.io/otel/internal/baggage
go.opentelemetry.io/otel/internal/errorhandler
go.opentelemetry.io/otel/internal/global
go.opentelemetry.io/otel/propagation
+go.opentelemetry.io/otel/semconv/internal/metricpool
go.opentelemetry.io/otel/semconv/v1.17.0
go.opentelemetry.io/otel/semconv/v1.26.0
go.opentelemetry.io/otel/semconv/v1.37.0
-go.opentelemetry.io/otel/semconv/v1.41.0
-go.opentelemetry.io/otel/semconv/v1.41.0/otelconv
-# go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.20.0
+go.opentelemetry.io/otel/semconv/v1.43.0
+go.opentelemetry.io/otel/semconv/v1.43.0/otelconv
+# go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc v0.21.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal
@@ -1240,11 +1258,11 @@ go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/retry
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/transform
go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/x
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.44.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.45.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/exporters/otlp/otlptrace
go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.45.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal
@@ -1254,33 +1272,36 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry
go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x
-# go.opentelemetry.io/otel/log v0.20.0
+# go.opentelemetry.io/otel/log v0.21.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/log
go.opentelemetry.io/otel/log/embedded
go.opentelemetry.io/otel/log/global
go.opentelemetry.io/otel/log/internal/global
go.opentelemetry.io/otel/log/noop
-# go.opentelemetry.io/otel/metric v1.44.0
+# go.opentelemetry.io/otel/metric v1.45.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/metric
go.opentelemetry.io/otel/metric/embedded
go.opentelemetry.io/otel/metric/noop
-# go.opentelemetry.io/otel/sdk v1.44.0
+# go.opentelemetry.io/otel/sdk v1.45.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/sdk
go.opentelemetry.io/otel/sdk/instrumentation
+go.opentelemetry.io/otel/sdk/internal/attrnorm
go.opentelemetry.io/otel/sdk/internal/x
go.opentelemetry.io/otel/sdk/resource
go.opentelemetry.io/otel/sdk/trace
go.opentelemetry.io/otel/sdk/trace/internal/env
go.opentelemetry.io/otel/sdk/trace/internal/observ
-# go.opentelemetry.io/otel/sdk/log v0.20.0
+# go.opentelemetry.io/otel/sdk/log v0.21.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/sdk/log
+go.opentelemetry.io/otel/sdk/log/internal/attrnorm
+go.opentelemetry.io/otel/sdk/log/internal/counter
go.opentelemetry.io/otel/sdk/log/internal/observ
go.opentelemetry.io/otel/sdk/log/internal/x
-# go.opentelemetry.io/otel/trace v1.44.0
+# go.opentelemetry.io/otel/trace v1.45.0
## explicit; go 1.25.0
go.opentelemetry.io/otel/trace
go.opentelemetry.io/otel/trace/embedded
@@ -1410,10 +1431,10 @@ golang.org/x/tools/internal/stdlib
golang.org/x/tools/internal/typeparams
golang.org/x/tools/internal/typesinternal
golang.org/x/tools/internal/versions
-# google.golang.org/genproto/googleapis/api v0.0.0-20260729162451-8efbd57d26e0
+# google.golang.org/genproto/googleapis/api v0.0.0-20260803160001-6ac0973c030d
## explicit; go 1.25.0
google.golang.org/genproto/googleapis/api/httpbody
-# google.golang.org/genproto/googleapis/rpc v0.0.0-20260729162451-8efbd57d26e0
+# google.golang.org/genproto/googleapis/rpc v0.0.0-20260803160001-6ac0973c030d
## explicit; go 1.25.0
google.golang.org/genproto/googleapis/rpc/errdetails
google.golang.org/genproto/googleapis/rpc/status
@@ -1490,7 +1511,7 @@ google.golang.org/grpc/serviceconfig
google.golang.org/grpc/stats
google.golang.org/grpc/status
google.golang.org/grpc/tap
-# google.golang.org/protobuf v1.36.12-0.20260120151049-f2248ac996af
+# google.golang.org/protobuf v1.36.12-0.20260806062936-644d0267c26e
## explicit; go 1.23
google.golang.org/protobuf/encoding/protojson
google.golang.org/protobuf/encoding/prototext